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