drivers/net/ethernet/amd/xgbe/xgbe-mdio.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) 2014-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) 2014-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/interrupt.h>
 118 #include <linux/module.h>
 119 #include <linux/kmod.h>
 120 #include <linux/mdio.h>
 121 #include <linux/phy.h>
 122 #include <linux/of.h>
 123 #include <linux/bitops.h>
 124 #include <linux/jiffies.h>
 125
 126 #include "xgbe.h"
 127 #include "xgbe-common.h"
 128
 129 static int xgbe_phy_module_eeprom(struct xgbe_prv_data *pdata,
 130                                   struct ethtool_eeprom *eeprom, u8 *data)
 131 {
 132         if (!pdata->phy_if.phy_impl.module_eeprom)
 133                 return -ENXIO;
 134
 135         return pdata->phy_if.phy_impl.module_eeprom(pdata, eeprom, data);
 136 }
 137
 138 static int xgbe_phy_module_info(struct xgbe_prv_data *pdata,
 139                                 struct ethtool_modinfo *modinfo)
 140 {
 141         if (!pdata->phy_if.phy_impl.module_info)
 142                 return -ENXIO;
 143
 144         return pdata->phy_if.phy_impl.module_info(pdata, modinfo);
 145 }
 146
 147 static void xgbe_an37_clear_interrupts(struct xgbe_prv_data *pdata)
 148 {
 149         int reg;
 150
 151         reg = XMDIO_READ(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_STAT);
 152         reg &= ~XGBE_AN_CL37_INT_MASK;
 153         XMDIO_WRITE(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_STAT, reg);
 154 }
 155
 156 static void xgbe_an37_disable_interrupts(struct xgbe_prv_data *pdata)
 157 {
 158         int reg;
 159
 160         reg = XMDIO_READ(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_CTRL);
 161         reg &= ~XGBE_AN_CL37_INT_MASK;
 162         XMDIO_WRITE(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_CTRL, reg);
 163
 164         reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_PCS_DIG_CTRL);
 165         reg &= ~XGBE_PCS_CL37_BP;
 166         XMDIO_WRITE(pdata, MDIO_MMD_PCS, MDIO_PCS_DIG_CTRL, reg);
 167 }
 168
 169 static void xgbe_an37_enable_interrupts(struct xgbe_prv_data *pdata)
 170 {
 171         int reg;
 172
 173         reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_PCS_DIG_CTRL);
 174         reg |= XGBE_PCS_CL37_BP;
 175         XMDIO_WRITE(pdata, MDIO_MMD_PCS, MDIO_PCS_DIG_CTRL, reg);
 176
 177         reg = XMDIO_READ(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_CTRL);
 178         reg |= XGBE_AN_CL37_INT_MASK;
 179         XMDIO_WRITE(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_CTRL, reg);
 180 }
 181
 182 static void xgbe_an73_clear_interrupts(struct xgbe_prv_data *pdata)
 183 {
 184         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INT, 0);
 185 }
 186
 187 static void xgbe_an73_disable_interrupts(struct xgbe_prv_data *pdata)
 188 {
 189         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INTMASK, 0);
 190 }
 191
 192 static void xgbe_an73_enable_interrupts(struct xgbe_prv_data *pdata)
 193 {
 194         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INTMASK, XGBE_AN_CL73_INT_MASK);
 195 }
 196
 197 static void xgbe_an_enable_interrupts(struct xgbe_prv_data *pdata)
 198 {
 199         switch (pdata->an_mode) {
 200         case XGBE_AN_MODE_CL73:
 201         case XGBE_AN_MODE_CL73_REDRV:
 202                 xgbe_an73_enable_interrupts(pdata);
 203                 break;
 204         case XGBE_AN_MODE_CL37:
 205         case XGBE_AN_MODE_CL37_SGMII:
 206                 xgbe_an37_enable_interrupts(pdata);
 207                 break;
 208         default:
 209                 break;
 210         }
 211 }
 212
 213 static void xgbe_an_clear_interrupts_all(struct xgbe_prv_data *pdata)
 214 {
 215         xgbe_an73_clear_interrupts(pdata);
 216         xgbe_an37_clear_interrupts(pdata);
 217 }
 218
 219 static void xgbe_kr_mode(struct xgbe_prv_data *pdata)
 220 {
 221         /* Set MAC to 10G speed */
 222         pdata->hw_if.set_speed(pdata, SPEED_10000);
 223
 224         /* Call PHY implementation support to complete rate change */
 225         pdata->phy_if.phy_impl.set_mode(pdata, XGBE_MODE_KR);
 226 }
 227
 228 static void xgbe_kx_2500_mode(struct xgbe_prv_data *pdata)
 229 {
 230         /* Set MAC to 2.5G speed */
 231         pdata->hw_if.set_speed(pdata, SPEED_2500);
 232
 233         /* Call PHY implementation support to complete rate change */
 234         pdata->phy_if.phy_impl.set_mode(pdata, XGBE_MODE_KX_2500);
 235 }
 236
 237 static void xgbe_kx_1000_mode(struct xgbe_prv_data *pdata)
 238 {
 239         /* Set MAC to 1G speed */
 240         pdata->hw_if.set_speed(pdata, SPEED_1000);
 241
 242         /* Call PHY implementation support to complete rate change */
 243         pdata->phy_if.phy_impl.set_mode(pdata, XGBE_MODE_KX_1000);
 244 }
 245
 246 static void xgbe_sfi_mode(struct xgbe_prv_data *pdata)
 247 {
 248         /* If a KR re-driver is present, change to KR mode instead */
 249         if (pdata->kr_redrv)
 250                 return xgbe_kr_mode(pdata);
 251
 252         /* Set MAC to 10G speed */
 253         pdata->hw_if.set_speed(pdata, SPEED_10000);
 254
 255         /* Call PHY implementation support to complete rate change */
 256         pdata->phy_if.phy_impl.set_mode(pdata, XGBE_MODE_SFI);
 257 }
 258
 259 static void xgbe_x_mode(struct xgbe_prv_data *pdata)
 260 {
 261         /* Set MAC to 1G speed */
 262         pdata->hw_if.set_speed(pdata, SPEED_1000);
 263
 264         /* Call PHY implementation support to complete rate change */
 265         pdata->phy_if.phy_impl.set_mode(pdata, XGBE_MODE_X);
 266 }
 267
 268 static void xgbe_sgmii_1000_mode(struct xgbe_prv_data *pdata)
 269 {
 270         /* Set MAC to 1G speed */
 271         pdata->hw_if.set_speed(pdata, SPEED_1000);
 272
 273         /* Call PHY implementation support to complete rate change */
 274         pdata->phy_if.phy_impl.set_mode(pdata, XGBE_MODE_SGMII_1000);
 275 }
 276
 277 static void xgbe_sgmii_100_mode(struct xgbe_prv_data *pdata)
 278 {
 279         /* Set MAC to 1G speed */
 280         pdata->hw_if.set_speed(pdata, SPEED_1000);
 281
 282         /* Call PHY implementation support to complete rate change */
 283         pdata->phy_if.phy_impl.set_mode(pdata, XGBE_MODE_SGMII_100);
 284 }
 285
 286 static enum xgbe_mode xgbe_cur_mode(struct xgbe_prv_data *pdata)
 287 {
 288         return pdata->phy_if.phy_impl.cur_mode(pdata);
 289 }
 290
 291 static bool xgbe_in_kr_mode(struct xgbe_prv_data *pdata)
 292 {
 293         return (xgbe_cur_mode(pdata) == XGBE_MODE_KR);
 294 }
 295
 296 static void xgbe_change_mode(struct xgbe_prv_data *pdata,
 297                              enum xgbe_mode mode)
 298 {
 299         switch (mode) {
 300         case XGBE_MODE_KX_1000:
 301                 xgbe_kx_1000_mode(pdata);
 302                 break;
 303         case XGBE_MODE_KX_2500:
 304                 xgbe_kx_2500_mode(pdata);
 305                 break;
 306         case XGBE_MODE_KR:
 307                 xgbe_kr_mode(pdata);
 308                 break;
 309         case XGBE_MODE_SGMII_100:
 310                 xgbe_sgmii_100_mode(pdata);
 311                 break;
 312         case XGBE_MODE_SGMII_1000:
 313                 xgbe_sgmii_1000_mode(pdata);
 314                 break;
 315         case XGBE_MODE_X:
 316                 xgbe_x_mode(pdata);
 317                 break;
 318         case XGBE_MODE_SFI:
 319                 xgbe_sfi_mode(pdata);
 320                 break;
 321         case XGBE_MODE_UNKNOWN:
 322                 break;
 323         default:
 324                 netif_dbg(pdata, link, pdata->netdev,
 325                           "invalid operation mode requested (%u)\n", mode);
 326         }
 327 }
 328
 329 static void xgbe_switch_mode(struct xgbe_prv_data *pdata)
 330 {
 331         xgbe_change_mode(pdata, pdata->phy_if.phy_impl.switch_mode(pdata));
 332 }
 333
 334 static void xgbe_set_mode(struct xgbe_prv_data *pdata,
 335                           enum xgbe_mode mode)
 336 {
 337         if (mode == xgbe_cur_mode(pdata))
 338                 return;
 339
 340         xgbe_change_mode(pdata, mode);
 341 }
 342
 343 static bool xgbe_use_mode(struct xgbe_prv_data *pdata,
 344                           enum xgbe_mode mode)
 345 {
 346         return pdata->phy_if.phy_impl.use_mode(pdata, mode);
 347 }
 348
 349 static void xgbe_an37_set(struct xgbe_prv_data *pdata, bool enable,
 350                           bool restart)
 351 {
 352         unsigned int reg;
 353
 354         reg = XMDIO_READ(pdata, MDIO_MMD_VEND2, MDIO_CTRL1);
 355         reg &= ~MDIO_VEND2_CTRL1_AN_ENABLE;
 356
 357         if (enable)
 358                 reg |= MDIO_VEND2_CTRL1_AN_ENABLE;
 359
 360         if (restart)
 361                 reg |= MDIO_VEND2_CTRL1_AN_RESTART;
 362
 363         XMDIO_WRITE(pdata, MDIO_MMD_VEND2, MDIO_CTRL1, reg);
 364 }
 365
 366 static void xgbe_an37_restart(struct xgbe_prv_data *pdata)
 367 {
 368         xgbe_an37_enable_interrupts(pdata);
 369         xgbe_an37_set(pdata, true, true);
 370
 371         netif_dbg(pdata, link, pdata->netdev, "CL37 AN enabled/restarted\n");
 372 }
 373
 374 static void xgbe_an37_disable(struct xgbe_prv_data *pdata)
 375 {
 376         xgbe_an37_set(pdata, false, false);
 377         xgbe_an37_disable_interrupts(pdata);
 378
 379         netif_dbg(pdata, link, pdata->netdev, "CL37 AN disabled\n");
 380 }
 381
 382 static void xgbe_an73_set(struct xgbe_prv_data *pdata, bool enable,
 383                           bool restart)
 384 {
 385         unsigned int reg;
 386
 387         /* Disable KR training for now */
 388         reg = XMDIO_READ(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_PMD_CTRL);
 389         reg &= ~XGBE_KR_TRAINING_ENABLE;
 390         XMDIO_WRITE(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_PMD_CTRL, reg);
 391
 392         /* Update AN settings */
 393         reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_CTRL1);
 394         reg &= ~MDIO_AN_CTRL1_ENABLE;
 395
 396         if (enable)
 397                 reg |= MDIO_AN_CTRL1_ENABLE;
 398
 399         if (restart)
 400                 reg |= MDIO_AN_CTRL1_RESTART;
 401
 402         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_CTRL1, reg);
 403 }
 404
 405 static void xgbe_an73_restart(struct xgbe_prv_data *pdata)
 406 {
 407         xgbe_an73_enable_interrupts(pdata);
 408         xgbe_an73_set(pdata, true, true);
 409
 410         netif_dbg(pdata, link, pdata->netdev, "CL73 AN enabled/restarted\n");
 411 }
 412
 413 static void xgbe_an73_disable(struct xgbe_prv_data *pdata)
 414 {
 415         xgbe_an73_set(pdata, false, false);
 416         xgbe_an73_disable_interrupts(pdata);
 417
 418         pdata->an_start = 0;
 419
 420         netif_dbg(pdata, link, pdata->netdev, "CL73 AN disabled\n");
 421 }
 422
 423 static void xgbe_an_restart(struct xgbe_prv_data *pdata)
 424 {
 425         if (pdata->phy_if.phy_impl.an_pre)
 426                 pdata->phy_if.phy_impl.an_pre(pdata);
 427
 428         switch (pdata->an_mode) {
 429         case XGBE_AN_MODE_CL73:
 430         case XGBE_AN_MODE_CL73_REDRV:
 431                 xgbe_an73_restart(pdata);
 432                 break;
 433         case XGBE_AN_MODE_CL37:
 434         case XGBE_AN_MODE_CL37_SGMII:
 435                 xgbe_an37_restart(pdata);
 436                 break;
 437         default:
 438                 break;
 439         }
 440 }
 441
 442 static void xgbe_an_disable(struct xgbe_prv_data *pdata)
 443 {
 444         if (pdata->phy_if.phy_impl.an_post)
 445                 pdata->phy_if.phy_impl.an_post(pdata);
 446
 447         switch (pdata->an_mode) {
 448         case XGBE_AN_MODE_CL73:
 449         case XGBE_AN_MODE_CL73_REDRV:
 450                 xgbe_an73_disable(pdata);
 451                 break;
 452         case XGBE_AN_MODE_CL37:
 453         case XGBE_AN_MODE_CL37_SGMII:
 454                 xgbe_an37_disable(pdata);
 455                 break;
 456         default:
 457                 break;
 458         }
 459 }
 460
 461 static void xgbe_an_disable_all(struct xgbe_prv_data *pdata)
 462 {
 463         xgbe_an73_disable(pdata);
 464         xgbe_an37_disable(pdata);
 465 }
 466
 467 static enum xgbe_an xgbe_an73_tx_training(struct xgbe_prv_data *pdata,
 468                                           enum xgbe_rx *state)
 469 {
 470         unsigned int ad_reg, lp_reg, reg;
 471
 472         *state = XGBE_RX_COMPLETE;
 473
 474         /* If we're not in KR mode then we're done */
 475         if (!xgbe_in_kr_mode(pdata))
 476                 return XGBE_AN_PAGE_RECEIVED;
 477
 478         /* Enable/Disable FEC */
 479         ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 2);
 480         lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 2);
 481
 482         reg = XMDIO_READ(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_FECCTRL);
 483         reg &= ~(MDIO_PMA_10GBR_FECABLE_ABLE | MDIO_PMA_10GBR_FECABLE_ERRABLE);
 484         if ((ad_reg & 0xc000) && (lp_reg & 0xc000))
 485                 reg |= pdata->fec_ability;
 486
 487         XMDIO_WRITE(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_FECCTRL, reg);
 488
 489         /* Start KR training */
 490         if (pdata->phy_if.phy_impl.kr_training_pre)
 491                 pdata->phy_if.phy_impl.kr_training_pre(pdata);
 492
 493         reg = XMDIO_READ(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_PMD_CTRL);
 494         reg |= XGBE_KR_TRAINING_ENABLE;
 495         reg |= XGBE_KR_TRAINING_START;
 496         XMDIO_WRITE(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_PMD_CTRL, reg);
 497
 498         netif_dbg(pdata, link, pdata->netdev,
 499                   "KR training initiated\n");
 500
 501         if (pdata->phy_if.phy_impl.kr_training_post)
 502                 pdata->phy_if.phy_impl.kr_training_post(pdata);
 503
 504         return XGBE_AN_PAGE_RECEIVED;
 505 }
 506
 507 static enum xgbe_an xgbe_an73_tx_xnp(struct xgbe_prv_data *pdata,
 508                                      enum xgbe_rx *state)
 509 {
 510         u16 msg;
 511
 512         *state = XGBE_RX_XNP;
 513
 514         msg = XGBE_XNP_MCF_NULL_MESSAGE;
 515         msg |= XGBE_XNP_MP_FORMATTED;
 516
 517         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_XNP + 2, 0);
 518         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_XNP + 1, 0);
 519         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_XNP, msg);
 520
 521         return XGBE_AN_PAGE_RECEIVED;
 522 }
 523
 524 static enum xgbe_an xgbe_an73_rx_bpa(struct xgbe_prv_data *pdata,
 525                                      enum xgbe_rx *state)
 526 {
 527         unsigned int link_support;
 528         unsigned int reg, ad_reg, lp_reg;
 529
 530         /* Read Base Ability register 2 first */
 531         reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 1);
 532
 533         /* Check for a supported mode, otherwise restart in a different one */
 534         link_support = xgbe_in_kr_mode(pdata) ? 0x80 : 0x20;
 535         if (!(reg & link_support))
 536                 return XGBE_AN_INCOMPAT_LINK;
 537
 538         /* Check Extended Next Page support */
 539         ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE);
 540         lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA);
 541
 542         return ((ad_reg & XGBE_XNP_NP_EXCHANGE) ||
 543                 (lp_reg & XGBE_XNP_NP_EXCHANGE))
 544                ? xgbe_an73_tx_xnp(pdata, state)
 545                : xgbe_an73_tx_training(pdata, state);
 546 }
 547
 548 static enum xgbe_an xgbe_an73_rx_xnp(struct xgbe_prv_data *pdata,
 549                                      enum xgbe_rx *state)
 550 {
 551         unsigned int ad_reg, lp_reg;
 552
 553         /* Check Extended Next Page support */
 554         ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_XNP);
 555         lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPX);
 556
 557         return ((ad_reg & XGBE_XNP_NP_EXCHANGE) ||
 558                 (lp_reg & XGBE_XNP_NP_EXCHANGE))
 559                ? xgbe_an73_tx_xnp(pdata, state)
 560                : xgbe_an73_tx_training(pdata, state);
 561 }
 562
 563 static enum xgbe_an xgbe_an73_page_received(struct xgbe_prv_data *pdata)
 564 {
 565         enum xgbe_rx *state;
 566         unsigned long an_timeout;
 567         enum xgbe_an ret;
 568
 569         if (!pdata->an_start) {
 570                 pdata->an_start = jiffies;
 571         } else {
 572                 an_timeout = pdata->an_start +
 573                              msecs_to_jiffies(XGBE_AN_MS_TIMEOUT);
 574                 if (time_after(jiffies, an_timeout)) {
 575                         /* Auto-negotiation timed out, reset state */
 576                         pdata->kr_state = XGBE_RX_BPA;
 577                         pdata->kx_state = XGBE_RX_BPA;
 578
 579                         pdata->an_start = jiffies;
 580
 581                         netif_dbg(pdata, link, pdata->netdev,
 582                                   "CL73 AN timed out, resetting state\n");
 583                 }
 584         }
 585
 586         state = xgbe_in_kr_mode(pdata) ? &pdata->kr_state
 587                                        : &pdata->kx_state;
 588
 589         switch (*state) {
 590         case XGBE_RX_BPA:
 591                 ret = xgbe_an73_rx_bpa(pdata, state);
 592                 break;
 593
 594         case XGBE_RX_XNP:
 595                 ret = xgbe_an73_rx_xnp(pdata, state);
 596                 break;
 597
 598         default:
 599                 ret = XGBE_AN_ERROR;
 600         }
 601
 602         return ret;
 603 }
 604
 605 static enum xgbe_an xgbe_an73_incompat_link(struct xgbe_prv_data *pdata)
 606 {
 607         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
 608
 609         /* Be sure we aren't looping trying to negotiate */
 610         if (xgbe_in_kr_mode(pdata)) {
 611                 pdata->kr_state = XGBE_RX_ERROR;
 612
 613                 if (!XGBE_ADV(lks, 1000baseKX_Full) &&
 614                     !XGBE_ADV(lks, 2500baseX_Full))
 615                         return XGBE_AN_NO_LINK;
 616
 617                 if (pdata->kx_state != XGBE_RX_BPA)
 618                         return XGBE_AN_NO_LINK;
 619         } else {
 620                 pdata->kx_state = XGBE_RX_ERROR;
 621
 622                 if (!XGBE_ADV(lks, 10000baseKR_Full))
 623                         return XGBE_AN_NO_LINK;
 624
 625                 if (pdata->kr_state != XGBE_RX_BPA)
 626                         return XGBE_AN_NO_LINK;
 627         }
 628
 629         xgbe_an_disable(pdata);
 630
 631         xgbe_switch_mode(pdata);
 632
 633         xgbe_an_restart(pdata);
 634
 635         return XGBE_AN_INCOMPAT_LINK;
 636 }
 637
 638 static void xgbe_an37_isr(struct xgbe_prv_data *pdata)
 639 {
 640         unsigned int reg;
 641
 642         /* Disable AN interrupts */
 643         xgbe_an37_disable_interrupts(pdata);
 644
 645         /* Save the interrupt(s) that fired */
 646         reg = XMDIO_READ(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_STAT);
 647         pdata->an_int = reg & XGBE_AN_CL37_INT_MASK;
 648         pdata->an_status = reg & ~XGBE_AN_CL37_INT_MASK;
 649
 650         if (pdata->an_int) {
 651                 /* Clear the interrupt(s) that fired and process them */
 652                 reg &= ~XGBE_AN_CL37_INT_MASK;
 653                 XMDIO_WRITE(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_STAT, reg);
 654
 655                 queue_work(pdata->an_workqueue, &pdata->an_irq_work);
 656         } else {
 657                 /* Enable AN interrupts */
 658                 xgbe_an37_enable_interrupts(pdata);
 659
 660                 /* Reissue interrupt if status is not clear */
 661                 if (pdata->vdata->irq_reissue_support)
 662                         XP_IOWRITE(pdata, XP_INT_REISSUE_EN, 1 << 3);
 663         }
 664 }
 665
 666 static void xgbe_an73_isr(struct xgbe_prv_data *pdata)
 667 {
 668         /* Disable AN interrupts */
 669         xgbe_an73_disable_interrupts(pdata);
 670
 671         /* Save the interrupt(s) that fired */
 672         pdata->an_int = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_INT);
 673
 674         if (pdata->an_int) {
 675                 /* Clear the interrupt(s) that fired and process them */
 676                 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INT, ~pdata->an_int);
 677
 678                 queue_work(pdata->an_workqueue, &pdata->an_irq_work);
 679         } else {
 680                 /* Enable AN interrupts */
 681                 xgbe_an73_enable_interrupts(pdata);
 682
 683                 /* Reissue interrupt if status is not clear */
 684                 if (pdata->vdata->irq_reissue_support)
 685                         XP_IOWRITE(pdata, XP_INT_REISSUE_EN, 1 << 3);
 686         }
 687 }
 688
 689 static void xgbe_an_isr_task(unsigned long data)
 690 {
 691         struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)data;
 692
 693         netif_dbg(pdata, intr, pdata->netdev, "AN interrupt received\n");
 694
 695         switch (pdata->an_mode) {
 696         case XGBE_AN_MODE_CL73:
 697         case XGBE_AN_MODE_CL73_REDRV:
 698                 xgbe_an73_isr(pdata);
 699                 break;
 700         case XGBE_AN_MODE_CL37:
 701         case XGBE_AN_MODE_CL37_SGMII:
 702                 xgbe_an37_isr(pdata);
 703                 break;
 704         default:
 705                 break;
 706         }
 707 }
 708
 709 static irqreturn_t xgbe_an_isr(int irq, void *data)
 710 {
 711         struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)data;
 712
 713         if (pdata->isr_as_tasklet)
 714                 tasklet_schedule(&pdata->tasklet_an);
 715         else
 716                 xgbe_an_isr_task((unsigned long)pdata);
 717
 718         return IRQ_HANDLED;
 719 }
 720
 721 static irqreturn_t xgbe_an_combined_isr(struct xgbe_prv_data *pdata)
 722 {
 723         xgbe_an_isr_task((unsigned long)pdata);
 724
 725         return IRQ_HANDLED;
 726 }
 727
 728 static void xgbe_an_irq_work(struct work_struct *work)
 729 {
 730         struct xgbe_prv_data *pdata = container_of(work,
 731                                                    struct xgbe_prv_data,
 732                                                    an_irq_work);
 733
 734         /* Avoid a race between enabling the IRQ and exiting the work by
 735          * waiting for the work to finish and then queueing it
 736          */
 737         flush_work(&pdata->an_work);
 738         queue_work(pdata->an_workqueue, &pdata->an_work);
 739 }
 740
 741 static const char *xgbe_state_as_string(enum xgbe_an state)
 742 {
 743         switch (state) {
 744         case XGBE_AN_READY:
 745                 return "Ready";
 746         case XGBE_AN_PAGE_RECEIVED:
 747                 return "Page-Received";
 748         case XGBE_AN_INCOMPAT_LINK:
 749                 return "Incompatible-Link";
 750         case XGBE_AN_COMPLETE:
 751                 return "Complete";
 752         case XGBE_AN_NO_LINK:
 753                 return "No-Link";
 754         case XGBE_AN_ERROR:
 755                 return "Error";
 756         default:
 757                 return "Undefined";
 758         }
 759 }
 760
 761 static void xgbe_an37_state_machine(struct xgbe_prv_data *pdata)
 762 {
 763         enum xgbe_an cur_state = pdata->an_state;
 764
 765         if (!pdata->an_int)
 766                 return;
 767
 768         if (pdata->an_int & XGBE_AN_CL37_INT_CMPLT) {
 769                 pdata->an_state = XGBE_AN_COMPLETE;
 770                 pdata->an_int &= ~XGBE_AN_CL37_INT_CMPLT;
 771
 772                 /* If SGMII is enabled, check the link status */
 773                 if ((pdata->an_mode == XGBE_AN_MODE_CL37_SGMII) &&
 774                     !(pdata->an_status & XGBE_SGMII_AN_LINK_STATUS))
 775                         pdata->an_state = XGBE_AN_NO_LINK;
 776         }
 777
 778         netif_dbg(pdata, link, pdata->netdev, "CL37 AN %s\n",
 779                   xgbe_state_as_string(pdata->an_state));
 780
 781         cur_state = pdata->an_state;
 782
 783         switch (pdata->an_state) {
 784         case XGBE_AN_READY:
 785                 break;
 786
 787         case XGBE_AN_COMPLETE:
 788                 netif_dbg(pdata, link, pdata->netdev,
 789                           "Auto negotiation successful\n");
 790                 break;
 791
 792         case XGBE_AN_NO_LINK:
 793                 break;
 794
 795         default:
 796                 pdata->an_state = XGBE_AN_ERROR;
 797         }
 798
 799         if (pdata->an_state == XGBE_AN_ERROR) {
 800                 netdev_err(pdata->netdev,
 801                            "error during auto-negotiation, state=%u\n",
 802                            cur_state);
 803
 804                 pdata->an_int = 0;
 805                 xgbe_an37_clear_interrupts(pdata);
 806         }
 807
 808         if (pdata->an_state >= XGBE_AN_COMPLETE) {
 809                 pdata->an_result = pdata->an_state;
 810                 pdata->an_state = XGBE_AN_READY;
 811
 812                 if (pdata->phy_if.phy_impl.an_post)
 813                         pdata->phy_if.phy_impl.an_post(pdata);
 814
 815                 netif_dbg(pdata, link, pdata->netdev, "CL37 AN result: %s\n",
 816                           xgbe_state_as_string(pdata->an_result));
 817         }
 818
 819         xgbe_an37_enable_interrupts(pdata);
 820 }
 821
 822 static void xgbe_an73_state_machine(struct xgbe_prv_data *pdata)
 823 {
 824         enum xgbe_an cur_state = pdata->an_state;
 825
 826         if (!pdata->an_int)
 827                 return;
 828
 829 next_int:
 830         if (pdata->an_int & XGBE_AN_CL73_PG_RCV) {
 831                 pdata->an_state = XGBE_AN_PAGE_RECEIVED;
 832                 pdata->an_int &= ~XGBE_AN_CL73_PG_RCV;
 833         } else if (pdata->an_int & XGBE_AN_CL73_INC_LINK) {
 834                 pdata->an_state = XGBE_AN_INCOMPAT_LINK;
 835                 pdata->an_int &= ~XGBE_AN_CL73_INC_LINK;
 836         } else if (pdata->an_int & XGBE_AN_CL73_INT_CMPLT) {
 837                 pdata->an_state = XGBE_AN_COMPLETE;
 838                 pdata->an_int &= ~XGBE_AN_CL73_INT_CMPLT;
 839         } else {
 840                 pdata->an_state = XGBE_AN_ERROR;
 841         }
 842
 843 again:
 844         netif_dbg(pdata, link, pdata->netdev, "CL73 AN %s\n",
 845                   xgbe_state_as_string(pdata->an_state));
 846
 847         cur_state = pdata->an_state;
 848
 849         switch (pdata->an_state) {
 850         case XGBE_AN_READY:
 851                 pdata->an_supported = 0;
 852                 break;
 853
 854         case XGBE_AN_PAGE_RECEIVED:
 855                 pdata->an_state = xgbe_an73_page_received(pdata);
 856                 pdata->an_supported++;
 857                 break;
 858
 859         case XGBE_AN_INCOMPAT_LINK:
 860                 pdata->an_supported = 0;
 861                 pdata->parallel_detect = 0;
 862                 pdata->an_state = xgbe_an73_incompat_link(pdata);
 863                 break;
 864
 865         case XGBE_AN_COMPLETE:
 866                 pdata->parallel_detect = pdata->an_supported ? 0 : 1;
 867                 netif_dbg(pdata, link, pdata->netdev, "%s successful\n",
 868                           pdata->an_supported ? "Auto negotiation"
 869                                               : "Parallel detection");
 870                 break;
 871
 872         case XGBE_AN_NO_LINK:
 873                 break;
 874
 875         default:
 876                 pdata->an_state = XGBE_AN_ERROR;
 877         }
 878
 879         if (pdata->an_state == XGBE_AN_NO_LINK) {
 880                 pdata->an_int = 0;
 881                 xgbe_an73_clear_interrupts(pdata);
 882         } else if (pdata->an_state == XGBE_AN_ERROR) {
 883                 netdev_err(pdata->netdev,
 884                            "error during auto-negotiation, state=%u\n",
 885                            cur_state);
 886
 887                 pdata->an_int = 0;
 888                 xgbe_an73_clear_interrupts(pdata);
 889         }
 890
 891         if (pdata->an_state >= XGBE_AN_COMPLETE) {
 892                 pdata->an_result = pdata->an_state;
 893                 pdata->an_state = XGBE_AN_READY;
 894                 pdata->kr_state = XGBE_RX_BPA;
 895                 pdata->kx_state = XGBE_RX_BPA;
 896                 pdata->an_start = 0;
 897
 898                 if (pdata->phy_if.phy_impl.an_post)
 899                         pdata->phy_if.phy_impl.an_post(pdata);
 900
 901                 netif_dbg(pdata, link, pdata->netdev, "CL73 AN result: %s\n",
 902                           xgbe_state_as_string(pdata->an_result));
 903         }
 904
 905         if (cur_state != pdata->an_state)
 906                 goto again;
 907
 908         if (pdata->an_int)
 909                 goto next_int;
 910
 911         xgbe_an73_enable_interrupts(pdata);
 912 }
 913
 914 static void xgbe_an_state_machine(struct work_struct *work)
 915 {
 916         struct xgbe_prv_data *pdata = container_of(work,
 917                                                    struct xgbe_prv_data,
 918                                                    an_work);
 919
 920         mutex_lock(&pdata->an_mutex);
 921
 922         switch (pdata->an_mode) {
 923         case XGBE_AN_MODE_CL73:
 924         case XGBE_AN_MODE_CL73_REDRV:
 925                 xgbe_an73_state_machine(pdata);
 926                 break;
 927         case XGBE_AN_MODE_CL37:
 928         case XGBE_AN_MODE_CL37_SGMII:
 929                 xgbe_an37_state_machine(pdata);
 930                 break;
 931         default:
 932                 break;
 933         }
 934
 935         /* Reissue interrupt if status is not clear */
 936         if (pdata->vdata->irq_reissue_support)
 937                 XP_IOWRITE(pdata, XP_INT_REISSUE_EN, 1 << 3);
 938
 939         mutex_unlock(&pdata->an_mutex);
 940 }
 941
 942 static void xgbe_an37_init(struct xgbe_prv_data *pdata)
 943 {
 944         struct ethtool_link_ksettings lks;
 945         unsigned int reg;
 946
 947         pdata->phy_if.phy_impl.an_advertising(pdata, &lks);
 948
 949         /* Set up Advertisement register */
 950         reg = XMDIO_READ(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_ADVERTISE);
 951         if (XGBE_ADV(&lks, Pause))
 952                 reg |= 0x100;
 953         else
 954                 reg &= ~0x100;
 955
 956         if (XGBE_ADV(&lks, Asym_Pause))
 957                 reg |= 0x80;
 958         else
 959                 reg &= ~0x80;
 960
 961         /* Full duplex, but not half */
 962         reg |= XGBE_AN_CL37_FD_MASK;
 963         reg &= ~XGBE_AN_CL37_HD_MASK;
 964
 965         XMDIO_WRITE(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_ADVERTISE, reg);
 966
 967         /* Set up the Control register */
 968         reg = XMDIO_READ(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_CTRL);
 969         reg &= ~XGBE_AN_CL37_TX_CONFIG_MASK;
 970         reg &= ~XGBE_AN_CL37_PCS_MODE_MASK;
 971
 972         switch (pdata->an_mode) {
 973         case XGBE_AN_MODE_CL37:
 974                 reg |= XGBE_AN_CL37_PCS_MODE_BASEX;
 975                 break;
 976         case XGBE_AN_MODE_CL37_SGMII:
 977                 reg |= XGBE_AN_CL37_PCS_MODE_SGMII;
 978                 break;
 979         default:
 980                 break;
 981         }
 982
 983         reg |= XGBE_AN_CL37_MII_CTRL_8BIT;
 984
 985         XMDIO_WRITE(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_CTRL, reg);
 986
 987         netif_dbg(pdata, link, pdata->netdev, "CL37 AN (%s) initialized\n",
 988                   (pdata->an_mode == XGBE_AN_MODE_CL37) ? "BaseX" : "SGMII");
 989 }
 990
 991 static void xgbe_an73_init(struct xgbe_prv_data *pdata)
 992 {
 993         struct ethtool_link_ksettings lks;
 994         unsigned int reg;
 995
 996         pdata->phy_if.phy_impl.an_advertising(pdata, &lks);
 997
 998         /* Set up Advertisement register 3 first */
 999         reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 2);
1000         if (XGBE_ADV(&lks, 10000baseR_FEC))
1001                 reg |= 0xc000;
1002         else
1003                 reg &= ~0xc000;
1004
1005         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 2, reg);
1006
1007         /* Set up Advertisement register 2 next */
1008         reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 1);
1009         if (XGBE_ADV(&lks, 10000baseKR_Full))
1010                 reg |= 0x80;
1011         else
1012                 reg &= ~0x80;
1013
1014         if (XGBE_ADV(&lks, 1000baseKX_Full) ||
1015             XGBE_ADV(&lks, 2500baseX_Full))
1016                 reg |= 0x20;
1017         else
1018                 reg &= ~0x20;
1019
1020         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 1, reg);
1021
1022         /* Set up Advertisement register 1 last */
1023         reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE);
1024         if (XGBE_ADV(&lks, Pause))
1025                 reg |= 0x400;
1026         else
1027                 reg &= ~0x400;
1028
1029         if (XGBE_ADV(&lks, Asym_Pause))
1030                 reg |= 0x800;
1031         else
1032                 reg &= ~0x800;
1033
1034         /* We don't intend to perform XNP */
1035         reg &= ~XGBE_XNP_NP_EXCHANGE;
1036
1037         XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE, reg);
1038
1039         netif_dbg(pdata, link, pdata->netdev, "CL73 AN initialized\n");
1040 }
1041
1042 static void xgbe_an_init(struct xgbe_prv_data *pdata)
1043 {
1044         /* Set up advertisement registers based on current settings */
1045         pdata->an_mode = pdata->phy_if.phy_impl.an_mode(pdata);
1046         switch (pdata->an_mode) {
1047         case XGBE_AN_MODE_CL73:
1048         case XGBE_AN_MODE_CL73_REDRV:
1049                 xgbe_an73_init(pdata);
1050                 break;
1051         case XGBE_AN_MODE_CL37:
1052         case XGBE_AN_MODE_CL37_SGMII:
1053                 xgbe_an37_init(pdata);
1054                 break;
1055         default:
1056                 break;
1057         }
1058 }
1059
1060 static const char *xgbe_phy_fc_string(struct xgbe_prv_data *pdata)
1061 {
1062         if (pdata->tx_pause && pdata->rx_pause)
1063                 return "rx/tx";
1064         else if (pdata->rx_pause)
1065                 return "rx";
1066         else if (pdata->tx_pause)
1067                 return "tx";
1068         else
1069                 return "off";
1070 }
1071
1072 static const char *xgbe_phy_speed_string(int speed)
1073 {
1074         switch (speed) {
1075         case SPEED_100:
1076                 return "100Mbps";
1077         case SPEED_1000:
1078                 return "1Gbps";
1079         case SPEED_2500:
1080                 return "2.5Gbps";
1081         case SPEED_10000:
1082                 return "10Gbps";
1083         case SPEED_UNKNOWN:
1084                 return "Unknown";
1085         default:
1086                 return "Unsupported";
1087         }
1088 }
1089
1090 static void xgbe_phy_print_status(struct xgbe_prv_data *pdata)
1091 {
1092         if (pdata->phy.link)
1093                 netdev_info(pdata->netdev,
1094                             "Link is Up - %s/%s - flow control %s\n",
1095                             xgbe_phy_speed_string(pdata->phy.speed),
1096                             pdata->phy.duplex == DUPLEX_FULL ? "Full" : "Half",
1097                             xgbe_phy_fc_string(pdata));
1098         else
1099                 netdev_info(pdata->netdev, "Link is Down\n");
1100 }
1101
1102 static void xgbe_phy_adjust_link(struct xgbe_prv_data *pdata)
1103 {
1104         int new_state = 0;
1105
1106         if (pdata->phy.link) {
1107                 /* Flow control support */
1108                 pdata->pause_autoneg = pdata->phy.pause_autoneg;
1109
1110                 if (pdata->tx_pause != pdata->phy.tx_pause) {
1111                         new_state = 1;
1112                         pdata->hw_if.config_tx_flow_control(pdata);
1113                         pdata->tx_pause = pdata->phy.tx_pause;
1114                 }
1115
1116                 if (pdata->rx_pause != pdata->phy.rx_pause) {
1117                         new_state = 1;
1118                         pdata->hw_if.config_rx_flow_control(pdata);
1119                         pdata->rx_pause = pdata->phy.rx_pause;
1120                 }
1121
1122                 /* Speed support */
1123                 if (pdata->phy_speed != pdata->phy.speed) {
1124                         new_state = 1;
1125                         pdata->phy_speed = pdata->phy.speed;
1126                 }
1127
1128                 if (pdata->phy_link != pdata->phy.link) {
1129                         new_state = 1;
1130                         pdata->phy_link = pdata->phy.link;
1131                 }
1132         } else if (pdata->phy_link) {
1133                 new_state = 1;
1134                 pdata->phy_link = 0;
1135                 pdata->phy_speed = SPEED_UNKNOWN;
1136         }
1137
1138         if (new_state && netif_msg_link(pdata))
1139                 xgbe_phy_print_status(pdata);
1140 }
1141
1142 static bool xgbe_phy_valid_speed(struct xgbe_prv_data *pdata, int speed)
1143 {
1144         return pdata->phy_if.phy_impl.valid_speed(pdata, speed);
1145 }
1146
1147 static int xgbe_phy_config_fixed(struct xgbe_prv_data *pdata)
1148 {
1149         enum xgbe_mode mode;
1150
1151         netif_dbg(pdata, link, pdata->netdev, "fixed PHY configuration\n");
1152
1153         /* Disable auto-negotiation */
1154         xgbe_an_disable(pdata);
1155
1156         /* Set specified mode for specified speed */
1157         mode = pdata->phy_if.phy_impl.get_mode(pdata, pdata->phy.speed);
1158         switch (mode) {
1159         case XGBE_MODE_KX_1000:
1160         case XGBE_MODE_KX_2500:
1161         case XGBE_MODE_KR:
1162         case XGBE_MODE_SGMII_100:
1163         case XGBE_MODE_SGMII_1000:
1164         case XGBE_MODE_X:
1165         case XGBE_MODE_SFI:
1166                 break;
1167         case XGBE_MODE_UNKNOWN:
1168         default:
1169                 return -EINVAL;
1170         }
1171
1172         /* Validate duplex mode */
1173         if (pdata->phy.duplex != DUPLEX_FULL)
1174                 return -EINVAL;
1175
1176         xgbe_set_mode(pdata, mode);
1177
1178         return 0;
1179 }
1180
1181 static int __xgbe_phy_config_aneg(struct xgbe_prv_data *pdata)
1182 {
1183         int ret;
1184
1185         set_bit(XGBE_LINK_INIT, &pdata->dev_state);
1186         pdata->link_check = jiffies;
1187
1188         ret = pdata->phy_if.phy_impl.an_config(pdata);
1189         if (ret)
1190                 return ret;
1191
1192         if (pdata->phy.autoneg != AUTONEG_ENABLE) {
1193                 ret = xgbe_phy_config_fixed(pdata);
1194                 if (ret || !pdata->kr_redrv)
1195                         return ret;
1196
1197                 netif_dbg(pdata, link, pdata->netdev, "AN redriver support\n");
1198         } else {
1199                 netif_dbg(pdata, link, pdata->netdev, "AN PHY configuration\n");
1200         }
1201
1202         /* Disable auto-negotiation interrupt */
1203         disable_irq(pdata->an_irq);
1204
1205         /* Start auto-negotiation in a supported mode */
1206         if (xgbe_use_mode(pdata, XGBE_MODE_KR)) {
1207                 xgbe_set_mode(pdata, XGBE_MODE_KR);
1208         } else if (xgbe_use_mode(pdata, XGBE_MODE_KX_2500)) {
1209                 xgbe_set_mode(pdata, XGBE_MODE_KX_2500);
1210         } else if (xgbe_use_mode(pdata, XGBE_MODE_KX_1000)) {
1211                 xgbe_set_mode(pdata, XGBE_MODE_KX_1000);
1212         } else if (xgbe_use_mode(pdata, XGBE_MODE_SFI)) {
1213                 xgbe_set_mode(pdata, XGBE_MODE_SFI);
1214         } else if (xgbe_use_mode(pdata, XGBE_MODE_X)) {
1215                 xgbe_set_mode(pdata, XGBE_MODE_X);
1216         } else if (xgbe_use_mode(pdata, XGBE_MODE_SGMII_1000)) {
1217                 xgbe_set_mode(pdata, XGBE_MODE_SGMII_1000);
1218         } else if (xgbe_use_mode(pdata, XGBE_MODE_SGMII_100)) {
1219                 xgbe_set_mode(pdata, XGBE_MODE_SGMII_100);
1220         } else {
1221                 enable_irq(pdata->an_irq);
1222                 return -EINVAL;
1223         }
1224
1225         /* Disable and stop any in progress auto-negotiation */
1226         xgbe_an_disable_all(pdata);
1227
1228         /* Clear any auto-negotitation interrupts */
1229         xgbe_an_clear_interrupts_all(pdata);
1230
1231         pdata->an_result = XGBE_AN_READY;
1232         pdata->an_state = XGBE_AN_READY;
1233         pdata->kr_state = XGBE_RX_BPA;
1234         pdata->kx_state = XGBE_RX_BPA;
1235
1236         /* Re-enable auto-negotiation interrupt */
1237         enable_irq(pdata->an_irq);
1238
1239         xgbe_an_init(pdata);
1240         xgbe_an_restart(pdata);
1241
1242         return 0;
1243 }
1244
1245 static int xgbe_phy_config_aneg(struct xgbe_prv_data *pdata)
1246 {
1247         int ret;
1248
1249         mutex_lock(&pdata->an_mutex);
1250
1251         ret = __xgbe_phy_config_aneg(pdata);
1252         if (ret)
1253                 set_bit(XGBE_LINK_ERR, &pdata->dev_state);
1254         else
1255                 clear_bit(XGBE_LINK_ERR, &pdata->dev_state);
1256
1257         mutex_unlock(&pdata->an_mutex);
1258
1259         return ret;
1260 }
1261
1262 static bool xgbe_phy_aneg_done(struct xgbe_prv_data *pdata)
1263 {
1264         return (pdata->an_result == XGBE_AN_COMPLETE);
1265 }
1266
1267 static void xgbe_check_link_timeout(struct xgbe_prv_data *pdata)
1268 {
1269         unsigned long link_timeout;
1270
1271         link_timeout = pdata->link_check + (XGBE_LINK_TIMEOUT * HZ);
1272         if (time_after(jiffies, link_timeout)) {
1273                 netif_dbg(pdata, link, pdata->netdev, "AN link timeout\n");
1274                 xgbe_phy_config_aneg(pdata);
1275         }
1276 }
1277
1278 static enum xgbe_mode xgbe_phy_status_aneg(struct xgbe_prv_data *pdata)
1279 {
1280         return pdata->phy_if.phy_impl.an_outcome(pdata);
1281 }
1282
1283 static void xgbe_phy_status_result(struct xgbe_prv_data *pdata)
1284 {
1285         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
1286         enum xgbe_mode mode;
1287
1288         XGBE_ZERO_LP_ADV(lks);
1289
1290         if ((pdata->phy.autoneg != AUTONEG_ENABLE) || pdata->parallel_detect)
1291                 mode = xgbe_cur_mode(pdata);
1292         else
1293                 mode = xgbe_phy_status_aneg(pdata);
1294
1295         switch (mode) {
1296         case XGBE_MODE_SGMII_100:
1297                 pdata->phy.speed = SPEED_100;
1298                 break;
1299         case XGBE_MODE_X:
1300         case XGBE_MODE_KX_1000:
1301         case XGBE_MODE_SGMII_1000:
1302                 pdata->phy.speed = SPEED_1000;
1303                 break;
1304         case XGBE_MODE_KX_2500:
1305                 pdata->phy.speed = SPEED_2500;
1306                 break;
1307         case XGBE_MODE_KR:
1308         case XGBE_MODE_SFI:
1309                 pdata->phy.speed = SPEED_10000;
1310                 break;
1311         case XGBE_MODE_UNKNOWN:
1312         default:
1313                 pdata->phy.speed = SPEED_UNKNOWN;
1314         }
1315
1316         pdata->phy.duplex = DUPLEX_FULL;
1317
1318         xgbe_set_mode(pdata, mode);
1319 }
1320
1321 static void xgbe_phy_status(struct xgbe_prv_data *pdata)
1322 {
1323         unsigned int link_aneg;
1324         int an_restart;
1325
1326         if (test_bit(XGBE_LINK_ERR, &pdata->dev_state)) {
1327                 netif_carrier_off(pdata->netdev);
1328
1329                 pdata->phy.link = 0;
1330                 goto adjust_link;
1331         }
1332
1333         link_aneg = (pdata->phy.autoneg == AUTONEG_ENABLE);
1334
1335         pdata->phy.link = pdata->phy_if.phy_impl.link_status(pdata,
1336                                                              &an_restart);
1337         if (an_restart) {
1338                 xgbe_phy_config_aneg(pdata);
1339                 return;
1340         }
1341
1342         if (pdata->phy.link) {
1343                 if (link_aneg && !xgbe_phy_aneg_done(pdata)) {
1344                         xgbe_check_link_timeout(pdata);
1345                         return;
1346                 }
1347
1348                 xgbe_phy_status_result(pdata);
1349
1350                 if (test_bit(XGBE_LINK_INIT, &pdata->dev_state))
1351                         clear_bit(XGBE_LINK_INIT, &pdata->dev_state);
1352
1353                 netif_carrier_on(pdata->netdev);
1354         } else {
1355                 if (test_bit(XGBE_LINK_INIT, &pdata->dev_state)) {
1356                         xgbe_check_link_timeout(pdata);
1357
1358                         if (link_aneg)
1359                                 return;
1360                 }
1361
1362                 xgbe_phy_status_result(pdata);
1363
1364                 netif_carrier_off(pdata->netdev);
1365         }
1366
1367 adjust_link:
1368         xgbe_phy_adjust_link(pdata);
1369 }
1370
1371 static void xgbe_phy_stop(struct xgbe_prv_data *pdata)
1372 {
1373         netif_dbg(pdata, link, pdata->netdev, "stopping PHY\n");
1374
1375         if (!pdata->phy_started)
1376                 return;
1377
1378         /* Indicate the PHY is down */
1379         pdata->phy_started = 0;
1380
1381         /* Disable auto-negotiation */
1382         xgbe_an_disable_all(pdata);
1383
1384         if (pdata->dev_irq != pdata->an_irq)
1385                 devm_free_irq(pdata->dev, pdata->an_irq, pdata);
1386
1387         pdata->phy_if.phy_impl.stop(pdata);
1388
1389         pdata->phy.link = 0;
1390         netif_carrier_off(pdata->netdev);
1391
1392         xgbe_phy_adjust_link(pdata);
1393 }
1394
1395 static int xgbe_phy_start(struct xgbe_prv_data *pdata)
1396 {
1397         struct net_device *netdev = pdata->netdev;
1398         int ret;
1399
1400         netif_dbg(pdata, link, pdata->netdev, "starting PHY\n");
1401
1402         ret = pdata->phy_if.phy_impl.start(pdata);
1403         if (ret)
1404                 return ret;
1405
1406         /* If we have a separate AN irq, enable it */
1407         if (pdata->dev_irq != pdata->an_irq) {
1408                 tasklet_init(&pdata->tasklet_an, xgbe_an_isr_task,
1409                              (unsigned long)pdata);
1410
1411                 ret = devm_request_irq(pdata->dev, pdata->an_irq,
1412                                        xgbe_an_isr, 0, pdata->an_name,
1413                                        pdata);
1414                 if (ret) {
1415                         netdev_err(netdev, "phy irq request failed\n");
1416                         goto err_stop;
1417                 }
1418         }
1419
1420         /* Set initial mode - call the mode setting routines
1421          * directly to insure we are properly configured
1422          */
1423         if (xgbe_use_mode(pdata, XGBE_MODE_KR)) {
1424                 xgbe_kr_mode(pdata);
1425         } else if (xgbe_use_mode(pdata, XGBE_MODE_KX_2500)) {
1426                 xgbe_kx_2500_mode(pdata);
1427         } else if (xgbe_use_mode(pdata, XGBE_MODE_KX_1000)) {
1428                 xgbe_kx_1000_mode(pdata);
1429         } else if (xgbe_use_mode(pdata, XGBE_MODE_SFI)) {
1430                 xgbe_sfi_mode(pdata);
1431         } else if (xgbe_use_mode(pdata, XGBE_MODE_X)) {
1432                 xgbe_x_mode(pdata);
1433         } else if (xgbe_use_mode(pdata, XGBE_MODE_SGMII_1000)) {
1434                 xgbe_sgmii_1000_mode(pdata);
1435         } else if (xgbe_use_mode(pdata, XGBE_MODE_SGMII_100)) {
1436                 xgbe_sgmii_100_mode(pdata);
1437         } else {
1438                 ret = -EINVAL;
1439                 goto err_irq;
1440         }
1441
1442         /* Indicate the PHY is up and running */
1443         pdata->phy_started = 1;
1444
1445         xgbe_an_init(pdata);
1446         xgbe_an_enable_interrupts(pdata);
1447
1448         return xgbe_phy_config_aneg(pdata);
1449
1450 err_irq:
1451         if (pdata->dev_irq != pdata->an_irq)
1452                 devm_free_irq(pdata->dev, pdata->an_irq, pdata);
1453
1454 err_stop:
1455         pdata->phy_if.phy_impl.stop(pdata);
1456
1457         return ret;
1458 }
1459
1460 static int xgbe_phy_reset(struct xgbe_prv_data *pdata)
1461 {
1462         int ret;
1463
1464         ret = pdata->phy_if.phy_impl.reset(pdata);
1465         if (ret)
1466                 return ret;
1467
1468         /* Disable auto-negotiation for now */
1469         xgbe_an_disable_all(pdata);
1470
1471         /* Clear auto-negotiation interrupts */
1472         xgbe_an_clear_interrupts_all(pdata);
1473
1474         return 0;
1475 }
1476
1477 static void xgbe_dump_phy_registers(struct xgbe_prv_data *pdata)
1478 {
1479         struct device *dev = pdata->dev;
1480
1481         dev_dbg(dev, "\n************* PHY Reg dump **********************\n");
1482
1483         dev_dbg(dev, "PCS Control Reg (%#06x) = %#06x\n", MDIO_CTRL1,
1484                 XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_CTRL1));
1485         dev_dbg(dev, "PCS Status Reg (%#06x) = %#06x\n", MDIO_STAT1,
1486                 XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_STAT1));
1487         dev_dbg(dev, "Phy Id (PHYS ID 1 %#06x)= %#06x\n", MDIO_DEVID1,
1488                 XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_DEVID1));
1489         dev_dbg(dev, "Phy Id (PHYS ID 2 %#06x)= %#06x\n", MDIO_DEVID2,
1490                 XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_DEVID2));
1491         dev_dbg(dev, "Devices in Package (%#06x)= %#06x\n", MDIO_DEVS1,
1492                 XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_DEVS1));
1493         dev_dbg(dev, "Devices in Package (%#06x)= %#06x\n", MDIO_DEVS2,
1494                 XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_DEVS2));
1495
1496         dev_dbg(dev, "Auto-Neg Control Reg (%#06x) = %#06x\n", MDIO_CTRL1,
1497                 XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_CTRL1));
1498         dev_dbg(dev, "Auto-Neg Status Reg (%#06x) = %#06x\n", MDIO_STAT1,
1499                 XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_STAT1));
1500         dev_dbg(dev, "Auto-Neg Ad Reg 1 (%#06x) = %#06x\n",
1501                 MDIO_AN_ADVERTISE,
1502                 XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE));
1503         dev_dbg(dev, "Auto-Neg Ad Reg 2 (%#06x) = %#06x\n",
1504                 MDIO_AN_ADVERTISE + 1,
1505                 XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 1));
1506         dev_dbg(dev, "Auto-Neg Ad Reg 3 (%#06x) = %#06x\n",
1507                 MDIO_AN_ADVERTISE + 2,
1508                 XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 2));
1509         dev_dbg(dev, "Auto-Neg Completion Reg (%#06x) = %#06x\n",
1510                 MDIO_AN_COMP_STAT,
1511                 XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_COMP_STAT));
1512
1513         dev_dbg(dev, "\n*************************************************\n");
1514 }
1515
1516 static int xgbe_phy_best_advertised_speed(struct xgbe_prv_data *pdata)
1517 {
1518         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
1519
1520         if (XGBE_ADV(lks, 10000baseKR_Full))
1521                 return SPEED_10000;
1522         else if (XGBE_ADV(lks, 10000baseT_Full))
1523                 return SPEED_10000;
1524         else if (XGBE_ADV(lks, 2500baseX_Full))
1525                 return SPEED_2500;
1526         else if (XGBE_ADV(lks, 2500baseT_Full))
1527                 return SPEED_2500;
1528         else if (XGBE_ADV(lks, 1000baseKX_Full))
1529                 return SPEED_1000;
1530         else if (XGBE_ADV(lks, 1000baseT_Full))
1531                 return SPEED_1000;
1532         else if (XGBE_ADV(lks, 100baseT_Full))
1533                 return SPEED_100;
1534
1535         return SPEED_UNKNOWN;
1536 }
1537
1538 static void xgbe_phy_exit(struct xgbe_prv_data *pdata)
1539 {
1540         pdata->phy_if.phy_impl.exit(pdata);
1541 }
1542
1543 static int xgbe_phy_init(struct xgbe_prv_data *pdata)
1544 {
1545         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
1546         int ret;
1547
1548         mutex_init(&pdata->an_mutex);
1549         INIT_WORK(&pdata->an_irq_work, xgbe_an_irq_work);
1550         INIT_WORK(&pdata->an_work, xgbe_an_state_machine);
1551         pdata->mdio_mmd = MDIO_MMD_PCS;
1552
1553         /* Check for FEC support */
1554         pdata->fec_ability = XMDIO_READ(pdata, MDIO_MMD_PMAPMD,
1555                                         MDIO_PMA_10GBR_FECABLE);
1556         pdata->fec_ability &= (MDIO_PMA_10GBR_FECABLE_ABLE |
1557                                MDIO_PMA_10GBR_FECABLE_ERRABLE);
1558
1559         /* Setup the phy (including supported features) */
1560         ret = pdata->phy_if.phy_impl.init(pdata);
1561         if (ret)
1562                 return ret;
1563
1564         /* Copy supported link modes to advertising link modes */
1565         XGBE_LM_COPY(lks, advertising, lks, supported);
1566
1567         pdata->phy.address = 0;
1568
1569         if (XGBE_ADV(lks, Autoneg)) {
1570                 pdata->phy.autoneg = AUTONEG_ENABLE;
1571                 pdata->phy.speed = SPEED_UNKNOWN;
1572                 pdata->phy.duplex = DUPLEX_UNKNOWN;
1573         } else {
1574                 pdata->phy.autoneg = AUTONEG_DISABLE;
1575                 pdata->phy.speed = xgbe_phy_best_advertised_speed(pdata);
1576                 pdata->phy.duplex = DUPLEX_FULL;
1577         }
1578
1579         pdata->phy.link = 0;
1580
1581         pdata->phy.pause_autoneg = pdata->pause_autoneg;
1582         pdata->phy.tx_pause = pdata->tx_pause;
1583         pdata->phy.rx_pause = pdata->rx_pause;
1584
1585         /* Fix up Flow Control advertising */
1586         XGBE_CLR_ADV(lks, Pause);
1587         XGBE_CLR_ADV(lks, Asym_Pause);
1588
1589         if (pdata->rx_pause) {
1590                 XGBE_SET_ADV(lks, Pause);
1591                 XGBE_SET_ADV(lks, Asym_Pause);
1592         }
1593
1594         if (pdata->tx_pause) {
1595                 /* Equivalent to XOR of Asym_Pause */
1596                 if (XGBE_ADV(lks, Asym_Pause))
1597                         XGBE_CLR_ADV(lks, Asym_Pause);
1598                 else
1599                         XGBE_SET_ADV(lks, Asym_Pause);
1600         }
1601
1602         if (netif_msg_drv(pdata))
1603                 xgbe_dump_phy_registers(pdata);
1604
1605         return 0;
1606 }
1607
1608 void xgbe_init_function_ptrs_phy(struct xgbe_phy_if *phy_if)
1609 {
1610         phy_if->phy_init        = xgbe_phy_init;
1611         phy_if->phy_exit        = xgbe_phy_exit;
1612
1613         phy_if->phy_reset       = xgbe_phy_reset;
1614         phy_if->phy_start       = xgbe_phy_start;
1615         phy_if->phy_stop        = xgbe_phy_stop;
1616
1617         phy_if->phy_status      = xgbe_phy_status;
1618         phy_if->phy_config_aneg = xgbe_phy_config_aneg;
1619
1620         phy_if->phy_valid_speed = xgbe_phy_valid_speed;
1621
1622         phy_if->an_isr          = xgbe_an_combined_isr;
1623
1624         phy_if->module_info     = xgbe_phy_module_info;
1625         phy_if->module_eeprom   = xgbe_phy_module_eeprom;
1626 }