2 * AMD 10Gb Ethernet driver
4 * This file is available to you under your choice of the following two
9 * Copyright (c) 2014-2016 Advanced Micro Devices, Inc.
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.
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.
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/>.
24 * This file incorporates work covered by the following copyright and
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
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:
41 * The above copyright notice and this permission notice shall be included
42 * in all copies or substantial portions of the Software.
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.
57 * License 2: Modified BSD
59 * Copyright (c) 2014-2016 Advanced Micro Devices, Inc.
60 * All rights reserved.
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.
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.
84 * This file incorporates work covered by the following copyright and
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
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:
101 * The above copyright notice and this permission notice shall be included
102 * in all copies or substantial portions of the Software.
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.
117 #include <sys/cdefs.h>
118 __FBSDID("$FreeBSD$");
120 #include <sys/param.h>
121 #include <sys/kernel.h>
124 #include "xgbe-common.h"
126 static void xgbe_an_state_machine(struct xgbe_prv_data *pdata);
128 static void xgbe_an_enable_kr_training(struct xgbe_prv_data *pdata)
132 reg = XMDIO_READ(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_PMD_CTRL);
134 reg |= XGBE_KR_TRAINING_ENABLE;
135 XMDIO_WRITE(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_PMD_CTRL, reg);
138 static void xgbe_an_disable_kr_training(struct xgbe_prv_data *pdata)
142 reg = XMDIO_READ(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_PMD_CTRL);
144 reg &= ~XGBE_KR_TRAINING_ENABLE;
145 XMDIO_WRITE(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_PMD_CTRL, reg);
148 static void xgbe_pcs_power_cycle(struct xgbe_prv_data *pdata)
152 reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_CTRL1);
154 reg |= MDIO_CTRL1_LPOWER;
155 XMDIO_WRITE(pdata, MDIO_MMD_PCS, MDIO_CTRL1, reg);
159 reg &= ~MDIO_CTRL1_LPOWER;
160 XMDIO_WRITE(pdata, MDIO_MMD_PCS, MDIO_CTRL1, reg);
163 static void xgbe_serdes_start_ratechange(struct xgbe_prv_data *pdata)
165 /* Assert Rx and Tx ratechange */
166 XSIR1_IOWRITE_BITS(pdata, SIR1_SPEED, RATECHANGE, 1);
169 static void xgbe_serdes_complete_ratechange(struct xgbe_prv_data *pdata)
174 /* Release Rx and Tx ratechange */
175 XSIR1_IOWRITE_BITS(pdata, SIR1_SPEED, RATECHANGE, 0);
177 /* Wait for Rx and Tx ready */
178 wait = XGBE_RATECHANGE_COUNT;
182 status = XSIR0_IOREAD(pdata, SIR0_STATUS);
183 if (XSIR_GET_BITS(status, SIR0_STATUS, RX_READY) &&
184 XSIR_GET_BITS(status, SIR0_STATUS, TX_READY))
189 /* Perform Rx reset for the DFE changes */
190 XRXTX_IOWRITE_BITS(pdata, RXTX_REG6, RESETB_RXD, 0);
191 XRXTX_IOWRITE_BITS(pdata, RXTX_REG6, RESETB_RXD, 1);
194 static void xgbe_xgmii_mode(struct xgbe_prv_data *pdata)
198 /* Enable KR training */
199 xgbe_an_enable_kr_training(pdata);
201 /* Set MAC to 10G speed */
202 pdata->hw_if.set_xgmii_speed(pdata);
204 /* Set PCS to KR/10G speed */
205 reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_CTRL2);
206 reg &= ~MDIO_PCS_CTRL2_TYPE;
207 reg |= MDIO_PCS_CTRL2_10GBR;
208 XMDIO_WRITE(pdata, MDIO_MMD_PCS, MDIO_CTRL2, reg);
210 reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_CTRL1);
211 reg &= ~MDIO_CTRL1_SPEEDSEL;
212 reg |= MDIO_CTRL1_SPEED10G;
213 XMDIO_WRITE(pdata, MDIO_MMD_PCS, MDIO_CTRL1, reg);
215 xgbe_pcs_power_cycle(pdata);
217 /* Set SerDes to 10G speed */
218 xgbe_serdes_start_ratechange(pdata);
220 XSIR1_IOWRITE_BITS(pdata, SIR1_SPEED, DATARATE, XGBE_SPEED_10000_RATE);
221 XSIR1_IOWRITE_BITS(pdata, SIR1_SPEED, WORDMODE, XGBE_SPEED_10000_WORD);
222 XSIR1_IOWRITE_BITS(pdata, SIR1_SPEED, PLLSEL, XGBE_SPEED_10000_PLL);
224 XSIR1_IOWRITE_BITS(pdata, SIR1_SPEED, CDR_RATE,
225 pdata->serdes_cdr_rate[XGBE_SPEED_10000]);
226 XSIR1_IOWRITE_BITS(pdata, SIR1_SPEED, TXAMP,
227 pdata->serdes_tx_amp[XGBE_SPEED_10000]);
228 XRXTX_IOWRITE_BITS(pdata, RXTX_REG20, BLWC_ENA,
229 pdata->serdes_blwc[XGBE_SPEED_10000]);
230 XRXTX_IOWRITE_BITS(pdata, RXTX_REG114, PQ_REG,
231 pdata->serdes_pq_skew[XGBE_SPEED_10000]);
232 XRXTX_IOWRITE_BITS(pdata, RXTX_REG129, RXDFE_CONFIG,
233 pdata->serdes_dfe_tap_cfg[XGBE_SPEED_10000]);
234 XRXTX_IOWRITE(pdata, RXTX_REG22,
235 pdata->serdes_dfe_tap_ena[XGBE_SPEED_10000]);
237 xgbe_serdes_complete_ratechange(pdata);
240 static void xgbe_gmii_2500_mode(struct xgbe_prv_data *pdata)
244 /* Disable KR training */
245 xgbe_an_disable_kr_training(pdata);
247 /* Set MAC to 2.5G speed */
248 pdata->hw_if.set_gmii_2500_speed(pdata);
250 /* Set PCS to KX/1G speed */
251 reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_CTRL2);
252 reg &= ~MDIO_PCS_CTRL2_TYPE;
253 reg |= MDIO_PCS_CTRL2_10GBX;
254 XMDIO_WRITE(pdata, MDIO_MMD_PCS, MDIO_CTRL2, reg);
256 reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_CTRL1);
257 reg &= ~MDIO_CTRL1_SPEEDSEL;
258 reg |= MDIO_CTRL1_SPEED1G;
259 XMDIO_WRITE(pdata, MDIO_MMD_PCS, MDIO_CTRL1, reg);
261 xgbe_pcs_power_cycle(pdata);
263 /* Set SerDes to 2.5G speed */
264 xgbe_serdes_start_ratechange(pdata);
266 XSIR1_IOWRITE_BITS(pdata, SIR1_SPEED, DATARATE, XGBE_SPEED_2500_RATE);
267 XSIR1_IOWRITE_BITS(pdata, SIR1_SPEED, WORDMODE, XGBE_SPEED_2500_WORD);
268 XSIR1_IOWRITE_BITS(pdata, SIR1_SPEED, PLLSEL, XGBE_SPEED_2500_PLL);
270 XSIR1_IOWRITE_BITS(pdata, SIR1_SPEED, CDR_RATE,
271 pdata->serdes_cdr_rate[XGBE_SPEED_2500]);
272 XSIR1_IOWRITE_BITS(pdata, SIR1_SPEED, TXAMP,
273 pdata->serdes_tx_amp[XGBE_SPEED_2500]);
274 XRXTX_IOWRITE_BITS(pdata, RXTX_REG20, BLWC_ENA,
275 pdata->serdes_blwc[XGBE_SPEED_2500]);
276 XRXTX_IOWRITE_BITS(pdata, RXTX_REG114, PQ_REG,
277 pdata->serdes_pq_skew[XGBE_SPEED_2500]);
278 XRXTX_IOWRITE_BITS(pdata, RXTX_REG129, RXDFE_CONFIG,
279 pdata->serdes_dfe_tap_cfg[XGBE_SPEED_2500]);
280 XRXTX_IOWRITE(pdata, RXTX_REG22,
281 pdata->serdes_dfe_tap_ena[XGBE_SPEED_2500]);
283 xgbe_serdes_complete_ratechange(pdata);
286 static void xgbe_gmii_mode(struct xgbe_prv_data *pdata)
290 /* Disable KR training */
291 xgbe_an_disable_kr_training(pdata);
293 /* Set MAC to 1G speed */
294 pdata->hw_if.set_gmii_speed(pdata);
296 /* Set PCS to KX/1G speed */
297 reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_CTRL2);
298 reg &= ~MDIO_PCS_CTRL2_TYPE;
299 reg |= MDIO_PCS_CTRL2_10GBX;
300 XMDIO_WRITE(pdata, MDIO_MMD_PCS, MDIO_CTRL2, reg);
302 reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_CTRL1);
303 reg &= ~MDIO_CTRL1_SPEEDSEL;
304 reg |= MDIO_CTRL1_SPEED1G;
305 XMDIO_WRITE(pdata, MDIO_MMD_PCS, MDIO_CTRL1, reg);
307 xgbe_pcs_power_cycle(pdata);
309 /* Set SerDes to 1G speed */
310 xgbe_serdes_start_ratechange(pdata);
312 XSIR1_IOWRITE_BITS(pdata, SIR1_SPEED, DATARATE, XGBE_SPEED_1000_RATE);
313 XSIR1_IOWRITE_BITS(pdata, SIR1_SPEED, WORDMODE, XGBE_SPEED_1000_WORD);
314 XSIR1_IOWRITE_BITS(pdata, SIR1_SPEED, PLLSEL, XGBE_SPEED_1000_PLL);
316 XSIR1_IOWRITE_BITS(pdata, SIR1_SPEED, CDR_RATE,
317 pdata->serdes_cdr_rate[XGBE_SPEED_1000]);
318 XSIR1_IOWRITE_BITS(pdata, SIR1_SPEED, TXAMP,
319 pdata->serdes_tx_amp[XGBE_SPEED_1000]);
320 XRXTX_IOWRITE_BITS(pdata, RXTX_REG20, BLWC_ENA,
321 pdata->serdes_blwc[XGBE_SPEED_1000]);
322 XRXTX_IOWRITE_BITS(pdata, RXTX_REG114, PQ_REG,
323 pdata->serdes_pq_skew[XGBE_SPEED_1000]);
324 XRXTX_IOWRITE_BITS(pdata, RXTX_REG129, RXDFE_CONFIG,
325 pdata->serdes_dfe_tap_cfg[XGBE_SPEED_1000]);
326 XRXTX_IOWRITE(pdata, RXTX_REG22,
327 pdata->serdes_dfe_tap_ena[XGBE_SPEED_1000]);
329 xgbe_serdes_complete_ratechange(pdata);
332 static void xgbe_cur_mode(struct xgbe_prv_data *pdata,
333 enum xgbe_mode *mode)
337 reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_CTRL2);
338 if ((reg & MDIO_PCS_CTRL2_TYPE) == MDIO_PCS_CTRL2_10GBR)
339 *mode = XGBE_MODE_KR;
341 *mode = XGBE_MODE_KX;
344 static bool xgbe_in_kr_mode(struct xgbe_prv_data *pdata)
348 xgbe_cur_mode(pdata, &mode);
350 return (mode == XGBE_MODE_KR);
353 static void xgbe_switch_mode(struct xgbe_prv_data *pdata)
355 /* If we are in KR switch to KX, and vice-versa */
356 if (xgbe_in_kr_mode(pdata)) {
357 if (pdata->speed_set == XGBE_SPEEDSET_1000_10000)
358 xgbe_gmii_mode(pdata);
360 xgbe_gmii_2500_mode(pdata);
362 xgbe_xgmii_mode(pdata);
366 static void xgbe_set_mode(struct xgbe_prv_data *pdata,
369 enum xgbe_mode cur_mode;
371 xgbe_cur_mode(pdata, &cur_mode);
372 if (mode != cur_mode)
373 xgbe_switch_mode(pdata);
376 static bool xgbe_use_xgmii_mode(struct xgbe_prv_data *pdata)
378 if (pdata->phy.autoneg == AUTONEG_ENABLE) {
379 if (pdata->phy.advertising & ADVERTISED_10000baseKR_Full)
382 if (pdata->phy.speed == SPEED_10000)
389 static bool xgbe_use_gmii_2500_mode(struct xgbe_prv_data *pdata)
391 if (pdata->phy.autoneg == AUTONEG_ENABLE) {
392 if (pdata->phy.advertising & ADVERTISED_2500baseX_Full)
395 if (pdata->phy.speed == SPEED_2500)
402 static bool xgbe_use_gmii_mode(struct xgbe_prv_data *pdata)
404 if (pdata->phy.autoneg == AUTONEG_ENABLE) {
405 if (pdata->phy.advertising & ADVERTISED_1000baseKX_Full)
408 if (pdata->phy.speed == SPEED_1000)
415 static void xgbe_set_an(struct xgbe_prv_data *pdata, bool enable, bool restart)
419 reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_CTRL1);
420 reg &= ~MDIO_AN_CTRL1_ENABLE;
423 reg |= MDIO_AN_CTRL1_ENABLE;
426 reg |= MDIO_AN_CTRL1_RESTART;
428 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_CTRL1, reg);
431 static void xgbe_restart_an(struct xgbe_prv_data *pdata)
433 xgbe_set_an(pdata, true, true);
436 static void xgbe_disable_an(struct xgbe_prv_data *pdata)
438 xgbe_set_an(pdata, false, false);
441 static enum xgbe_an xgbe_an_tx_training(struct xgbe_prv_data *pdata,
444 unsigned int ad_reg, lp_reg, reg;
446 *state = XGBE_RX_COMPLETE;
448 /* If we're not in KR mode then we're done */
449 if (!xgbe_in_kr_mode(pdata))
450 return XGBE_AN_PAGE_RECEIVED;
452 /* Enable/Disable FEC */
453 ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 2);
454 lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 2);
456 reg = XMDIO_READ(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_FECCTRL);
457 reg &= ~(MDIO_PMA_10GBR_FECABLE_ABLE | MDIO_PMA_10GBR_FECABLE_ERRABLE);
458 if ((ad_reg & 0xc000) && (lp_reg & 0xc000))
459 reg |= pdata->fec_ability;
461 XMDIO_WRITE(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_FECCTRL, reg);
463 /* Start KR training */
464 reg = XMDIO_READ(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_PMD_CTRL);
465 if (reg & XGBE_KR_TRAINING_ENABLE) {
466 XSIR0_IOWRITE_BITS(pdata, SIR0_KR_RT_1, RESET, 1);
468 reg |= XGBE_KR_TRAINING_START;
469 XMDIO_WRITE(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_10GBR_PMD_CTRL,
472 XSIR0_IOWRITE_BITS(pdata, SIR0_KR_RT_1, RESET, 0);
475 return XGBE_AN_PAGE_RECEIVED;
478 static enum xgbe_an xgbe_an_tx_xnp(struct xgbe_prv_data *pdata,
483 *state = XGBE_RX_XNP;
485 msg = XGBE_XNP_MCF_NULL_MESSAGE;
486 msg |= XGBE_XNP_MP_FORMATTED;
488 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_XNP + 2, 0);
489 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_XNP + 1, 0);
490 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_XNP, msg);
492 return XGBE_AN_PAGE_RECEIVED;
495 static enum xgbe_an xgbe_an_rx_bpa(struct xgbe_prv_data *pdata,
498 unsigned int link_support;
499 unsigned int reg, ad_reg, lp_reg;
501 /* Read Base Ability register 2 first */
502 reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 1);
504 /* Check for a supported mode, otherwise restart in a different one */
505 link_support = xgbe_in_kr_mode(pdata) ? 0x80 : 0x20;
506 if (!(reg & link_support))
507 return XGBE_AN_INCOMPAT_LINK;
509 /* Check Extended Next Page support */
510 ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE);
511 lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA);
513 return ((ad_reg & XGBE_XNP_NP_EXCHANGE) ||
514 (lp_reg & XGBE_XNP_NP_EXCHANGE))
515 ? xgbe_an_tx_xnp(pdata, state)
516 : xgbe_an_tx_training(pdata, state);
519 static enum xgbe_an xgbe_an_rx_xnp(struct xgbe_prv_data *pdata,
522 unsigned int ad_reg, lp_reg;
524 /* Check Extended Next Page support */
525 ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_XNP);
526 lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPX);
528 return ((ad_reg & XGBE_XNP_NP_EXCHANGE) ||
529 (lp_reg & XGBE_XNP_NP_EXCHANGE))
530 ? xgbe_an_tx_xnp(pdata, state)
531 : xgbe_an_tx_training(pdata, state);
534 static enum xgbe_an xgbe_an_page_received(struct xgbe_prv_data *pdata)
537 unsigned long an_timeout;
540 if (!pdata->an_start) {
541 pdata->an_start = ticks;
543 an_timeout = pdata->an_start +
544 ((uint64_t)XGBE_AN_MS_TIMEOUT * (uint64_t)hz) / 1000ull;
545 if ((int)(ticks - an_timeout) > 0) {
546 /* Auto-negotiation timed out, reset state */
547 pdata->kr_state = XGBE_RX_BPA;
548 pdata->kx_state = XGBE_RX_BPA;
550 pdata->an_start = ticks;
554 state = xgbe_in_kr_mode(pdata) ? &pdata->kr_state
559 ret = xgbe_an_rx_bpa(pdata, state);
563 ret = xgbe_an_rx_xnp(pdata, state);
573 static enum xgbe_an xgbe_an_incompat_link(struct xgbe_prv_data *pdata)
575 /* Be sure we aren't looping trying to negotiate */
576 if (xgbe_in_kr_mode(pdata)) {
577 pdata->kr_state = XGBE_RX_ERROR;
579 if (!(pdata->phy.advertising & ADVERTISED_1000baseKX_Full) &&
580 !(pdata->phy.advertising & ADVERTISED_2500baseX_Full))
581 return XGBE_AN_NO_LINK;
583 if (pdata->kx_state != XGBE_RX_BPA)
584 return XGBE_AN_NO_LINK;
586 pdata->kx_state = XGBE_RX_ERROR;
588 if (!(pdata->phy.advertising & ADVERTISED_10000baseKR_Full))
589 return XGBE_AN_NO_LINK;
591 if (pdata->kr_state != XGBE_RX_BPA)
592 return XGBE_AN_NO_LINK;
595 xgbe_disable_an(pdata);
597 xgbe_switch_mode(pdata);
599 xgbe_restart_an(pdata);
601 return XGBE_AN_INCOMPAT_LINK;
604 static void xgbe_an_isr(void *data)
606 struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)data;
608 /* Disable AN interrupts */
609 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INTMASK, 0);
611 /* Save the interrupt(s) that fired */
612 pdata->an_int = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_INT);
615 /* Clear the interrupt(s) that fired and process them */
616 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INT, ~pdata->an_int);
618 xgbe_an_state_machine(pdata);
620 /* Enable AN interrupts */
621 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INTMASK,
626 static void xgbe_an_state_machine(struct xgbe_prv_data *pdata)
628 enum xgbe_an cur_state = pdata->an_state;
630 sx_xlock(&pdata->an_mutex);
636 if (pdata->an_int & XGBE_AN_PG_RCV) {
637 pdata->an_state = XGBE_AN_PAGE_RECEIVED;
638 pdata->an_int &= ~XGBE_AN_PG_RCV;
639 } else if (pdata->an_int & XGBE_AN_INC_LINK) {
640 pdata->an_state = XGBE_AN_INCOMPAT_LINK;
641 pdata->an_int &= ~XGBE_AN_INC_LINK;
642 } else if (pdata->an_int & XGBE_AN_INT_CMPLT) {
643 pdata->an_state = XGBE_AN_COMPLETE;
644 pdata->an_int &= ~XGBE_AN_INT_CMPLT;
646 pdata->an_state = XGBE_AN_ERROR;
649 pdata->an_result = pdata->an_state;
652 cur_state = pdata->an_state;
654 switch (pdata->an_state) {
656 pdata->an_supported = 0;
659 case XGBE_AN_PAGE_RECEIVED:
660 pdata->an_state = xgbe_an_page_received(pdata);
661 pdata->an_supported++;
664 case XGBE_AN_INCOMPAT_LINK:
665 pdata->an_supported = 0;
666 pdata->parallel_detect = 0;
667 pdata->an_state = xgbe_an_incompat_link(pdata);
670 case XGBE_AN_COMPLETE:
671 pdata->parallel_detect = pdata->an_supported ? 0 : 1;
674 case XGBE_AN_NO_LINK:
678 pdata->an_state = XGBE_AN_ERROR;
681 if (pdata->an_state == XGBE_AN_NO_LINK) {
683 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INT, 0);
684 } else if (pdata->an_state == XGBE_AN_ERROR) {
686 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INT, 0);
689 if (pdata->an_state >= XGBE_AN_COMPLETE) {
690 pdata->an_result = pdata->an_state;
691 pdata->an_state = XGBE_AN_READY;
692 pdata->kr_state = XGBE_RX_BPA;
693 pdata->kx_state = XGBE_RX_BPA;
697 if (cur_state != pdata->an_state)
704 /* Enable AN interrupts on the way out */
705 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INTMASK, XGBE_AN_INT_MASK);
707 sx_xunlock(&pdata->an_mutex);
710 static void xgbe_an_init(struct xgbe_prv_data *pdata)
714 /* Set up Advertisement register 3 first */
715 reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 2);
718 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 2, reg);
720 /* Set up Advertisement register 2 next */
721 reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 1);
722 if (pdata->phy.advertising & ADVERTISED_10000baseKR_Full)
727 if ((pdata->phy.advertising & ADVERTISED_1000baseKX_Full) ||
728 (pdata->phy.advertising & ADVERTISED_2500baseX_Full))
733 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 1, reg);
735 /* Set up Advertisement register 1 last */
736 reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE);
737 if (pdata->phy.advertising & ADVERTISED_Pause)
742 if (pdata->phy.advertising & ADVERTISED_Asym_Pause)
747 /* We don't intend to perform XNP */
748 reg &= ~XGBE_XNP_NP_EXCHANGE;
750 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE, reg);
753 static void xgbe_phy_adjust_link(struct xgbe_prv_data *pdata)
756 if (pdata->phy.link) {
757 /* Flow control support */
758 pdata->pause_autoneg = pdata->phy.pause_autoneg;
760 if (pdata->tx_pause != pdata->phy.tx_pause) {
761 pdata->hw_if.config_tx_flow_control(pdata);
762 pdata->tx_pause = pdata->phy.tx_pause;
765 if (pdata->rx_pause != pdata->phy.rx_pause) {
766 pdata->hw_if.config_rx_flow_control(pdata);
767 pdata->rx_pause = pdata->phy.rx_pause;
771 if (pdata->phy_speed != pdata->phy.speed) {
772 pdata->phy_speed = pdata->phy.speed;
775 if (pdata->phy_link != pdata->phy.link) {
776 pdata->phy_link = pdata->phy.link;
778 } else if (pdata->phy_link) {
780 pdata->phy_speed = SPEED_UNKNOWN;
784 static int xgbe_phy_config_fixed(struct xgbe_prv_data *pdata)
787 /* Disable auto-negotiation */
788 xgbe_disable_an(pdata);
790 /* Validate/Set specified speed */
791 switch (pdata->phy.speed) {
793 xgbe_set_mode(pdata, XGBE_MODE_KR);
798 xgbe_set_mode(pdata, XGBE_MODE_KX);
805 /* Validate duplex mode */
806 if (pdata->phy.duplex != DUPLEX_FULL)
812 static int __xgbe_phy_config_aneg(struct xgbe_prv_data *pdata)
814 set_bit(XGBE_LINK_INIT, &pdata->dev_state);
815 pdata->link_check = ticks;
817 if (pdata->phy.autoneg != AUTONEG_ENABLE)
818 return xgbe_phy_config_fixed(pdata);
820 /* Disable auto-negotiation interrupt */
821 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INTMASK, 0);
823 /* Clear any auto-negotitation interrupts */
824 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INT, 0);
826 /* Start auto-negotiation in a supported mode */
827 if (pdata->phy.advertising & ADVERTISED_10000baseKR_Full) {
828 xgbe_set_mode(pdata, XGBE_MODE_KR);
829 } else if ((pdata->phy.advertising & ADVERTISED_1000baseKX_Full) ||
830 (pdata->phy.advertising & ADVERTISED_2500baseX_Full)) {
831 xgbe_set_mode(pdata, XGBE_MODE_KX);
833 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INTMASK, 0x07);
837 /* Disable and stop any in progress auto-negotiation */
838 xgbe_disable_an(pdata);
840 /* Clear any auto-negotitation interrupts */
841 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INT, 0);
843 pdata->an_result = XGBE_AN_READY;
844 pdata->an_state = XGBE_AN_READY;
845 pdata->kr_state = XGBE_RX_BPA;
846 pdata->kx_state = XGBE_RX_BPA;
848 /* Re-enable auto-negotiation interrupt */
849 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INTMASK, 0x07);
851 /* Set up advertisement registers based on current settings */
854 /* Enable and start auto-negotiation */
855 xgbe_restart_an(pdata);
860 static int xgbe_phy_config_aneg(struct xgbe_prv_data *pdata)
864 sx_xlock(&pdata->an_mutex);
866 ret = __xgbe_phy_config_aneg(pdata);
868 set_bit(XGBE_LINK_ERR, &pdata->dev_state);
870 clear_bit(XGBE_LINK_ERR, &pdata->dev_state);
872 sx_unlock(&pdata->an_mutex);
877 static bool xgbe_phy_aneg_done(struct xgbe_prv_data *pdata)
879 return (pdata->an_result == XGBE_AN_COMPLETE);
882 static void xgbe_check_link_timeout(struct xgbe_prv_data *pdata)
884 unsigned long link_timeout;
886 link_timeout = pdata->link_check + (XGBE_LINK_TIMEOUT * hz);
887 if ((int)(ticks - link_timeout) >= 0) {
888 xgbe_phy_config_aneg(pdata);
892 static void xgbe_phy_status_force(struct xgbe_prv_data *pdata)
894 if (xgbe_in_kr_mode(pdata)) {
895 pdata->phy.speed = SPEED_10000;
897 switch (pdata->speed_set) {
898 case XGBE_SPEEDSET_1000_10000:
899 pdata->phy.speed = SPEED_1000;
902 case XGBE_SPEEDSET_2500_10000:
903 pdata->phy.speed = SPEED_2500;
907 pdata->phy.duplex = DUPLEX_FULL;
910 static void xgbe_phy_status_aneg(struct xgbe_prv_data *pdata)
912 unsigned int ad_reg, lp_reg;
914 pdata->phy.lp_advertising = 0;
916 if ((pdata->phy.autoneg != AUTONEG_ENABLE) || pdata->parallel_detect)
917 return xgbe_phy_status_force(pdata);
919 pdata->phy.lp_advertising |= ADVERTISED_Autoneg;
920 pdata->phy.lp_advertising |= ADVERTISED_Backplane;
922 /* Compare Advertisement and Link Partner register 1 */
923 ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE);
924 lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA);
926 pdata->phy.lp_advertising |= ADVERTISED_Pause;
928 pdata->phy.lp_advertising |= ADVERTISED_Asym_Pause;
930 if (pdata->phy.pause_autoneg) {
931 /* Set flow control based on auto-negotiation result */
932 pdata->phy.tx_pause = 0;
933 pdata->phy.rx_pause = 0;
935 if (ad_reg & lp_reg & 0x400) {
936 pdata->phy.tx_pause = 1;
937 pdata->phy.rx_pause = 1;
938 } else if (ad_reg & lp_reg & 0x800) {
940 pdata->phy.rx_pause = 1;
941 else if (lp_reg & 0x400)
942 pdata->phy.tx_pause = 1;
946 /* Compare Advertisement and Link Partner register 2 */
947 ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 1);
948 lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 1);
950 pdata->phy.lp_advertising |= ADVERTISED_10000baseKR_Full;
952 switch (pdata->speed_set) {
953 case XGBE_SPEEDSET_1000_10000:
954 pdata->phy.lp_advertising |= ADVERTISED_1000baseKX_Full;
956 case XGBE_SPEEDSET_2500_10000:
957 pdata->phy.lp_advertising |= ADVERTISED_2500baseX_Full;
964 pdata->phy.speed = SPEED_10000;
965 xgbe_set_mode(pdata, XGBE_MODE_KR);
966 } else if (ad_reg & 0x20) {
967 switch (pdata->speed_set) {
968 case XGBE_SPEEDSET_1000_10000:
969 pdata->phy.speed = SPEED_1000;
972 case XGBE_SPEEDSET_2500_10000:
973 pdata->phy.speed = SPEED_2500;
977 xgbe_set_mode(pdata, XGBE_MODE_KX);
979 pdata->phy.speed = SPEED_UNKNOWN;
982 /* Compare Advertisement and Link Partner register 3 */
983 ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 2);
984 lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 2);
987 static void xgbe_phy_status(struct xgbe_prv_data *pdata)
989 unsigned int reg, link_aneg;
991 if (test_bit(XGBE_LINK_ERR, &pdata->dev_state)) {
996 link_aneg = (pdata->phy.autoneg == AUTONEG_ENABLE);
998 /* Get the link status. Link status is latched low, so read
999 * once to clear and then read again to get current state
1001 reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_STAT1);
1002 reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_STAT1);
1003 pdata->phy.link = (reg & MDIO_STAT1_LSTATUS) ? 1 : 0;
1005 if (pdata->phy.link) {
1006 if (link_aneg && !xgbe_phy_aneg_done(pdata)) {
1007 xgbe_check_link_timeout(pdata);
1011 xgbe_phy_status_aneg(pdata);
1013 if (test_bit(XGBE_LINK_INIT, &pdata->dev_state))
1014 clear_bit(XGBE_LINK_INIT, &pdata->dev_state);
1016 if (test_bit(XGBE_LINK_INIT, &pdata->dev_state)) {
1017 xgbe_check_link_timeout(pdata);
1023 xgbe_phy_status_aneg(pdata);
1027 xgbe_phy_adjust_link(pdata);
1030 static void xgbe_phy_stop(struct xgbe_prv_data *pdata)
1033 /* Disable auto-negotiation */
1034 xgbe_disable_an(pdata);
1036 /* Disable auto-negotiation interrupts */
1037 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INTMASK, 0);
1039 bus_teardown_intr(pdata->dev, pdata->an_irq_res, pdata->an_irq_tag);
1041 pdata->phy.link = 0;
1043 xgbe_phy_adjust_link(pdata);
1046 static int xgbe_phy_start(struct xgbe_prv_data *pdata)
1050 ret = bus_setup_intr(pdata->dev, pdata->an_irq_res,
1051 INTR_MPSAFE | INTR_TYPE_NET, NULL, xgbe_an_isr, pdata,
1052 &pdata->an_irq_tag);
1057 /* Set initial mode - call the mode setting routines
1058 * directly to insure we are properly configured
1060 if (xgbe_use_xgmii_mode(pdata)) {
1061 xgbe_xgmii_mode(pdata);
1062 } else if (xgbe_use_gmii_mode(pdata)) {
1063 xgbe_gmii_mode(pdata);
1064 } else if (xgbe_use_gmii_2500_mode(pdata)) {
1065 xgbe_gmii_2500_mode(pdata);
1071 /* Set up advertisement registers based on current settings */
1072 xgbe_an_init(pdata);
1074 /* Enable auto-negotiation interrupts */
1075 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INTMASK, 0x07);
1077 return xgbe_phy_config_aneg(pdata);
1080 bus_teardown_intr(pdata->dev, pdata->an_irq_res, pdata->an_irq_tag);
1085 static int xgbe_phy_reset(struct xgbe_prv_data *pdata)
1087 unsigned int count, reg;
1089 reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_CTRL1);
1090 reg |= MDIO_CTRL1_RESET;
1091 XMDIO_WRITE(pdata, MDIO_MMD_PCS, MDIO_CTRL1, reg);
1096 reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_CTRL1);
1097 } while ((reg & MDIO_CTRL1_RESET) && --count);
1099 if (reg & MDIO_CTRL1_RESET)
1102 /* Disable auto-negotiation for now */
1103 xgbe_disable_an(pdata);
1105 /* Clear auto-negotiation interrupts */
1106 XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_INT, 0);
1111 static void xgbe_phy_init(struct xgbe_prv_data *pdata)
1113 sx_init(&pdata->an_mutex, "axgbe AN lock");
1114 pdata->mdio_mmd = MDIO_MMD_PCS;
1116 /* Initialize supported features */
1117 pdata->phy.supported = SUPPORTED_Autoneg;
1118 pdata->phy.supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
1119 pdata->phy.supported |= SUPPORTED_Backplane;
1120 pdata->phy.supported |= SUPPORTED_10000baseKR_Full;
1121 switch (pdata->speed_set) {
1122 case XGBE_SPEEDSET_1000_10000:
1123 pdata->phy.supported |= SUPPORTED_1000baseKX_Full;
1125 case XGBE_SPEEDSET_2500_10000:
1126 pdata->phy.supported |= SUPPORTED_2500baseX_Full;
1130 pdata->fec_ability = XMDIO_READ(pdata, MDIO_MMD_PMAPMD,
1131 MDIO_PMA_10GBR_FECABLE);
1132 pdata->fec_ability &= (MDIO_PMA_10GBR_FECABLE_ABLE |
1133 MDIO_PMA_10GBR_FECABLE_ERRABLE);
1134 if (pdata->fec_ability & MDIO_PMA_10GBR_FECABLE_ABLE)
1135 pdata->phy.supported |= SUPPORTED_10000baseR_FEC;
1137 pdata->phy.advertising = pdata->phy.supported;
1139 pdata->phy.address = 0;
1141 pdata->phy.autoneg = AUTONEG_ENABLE;
1142 pdata->phy.speed = SPEED_UNKNOWN;
1143 pdata->phy.duplex = DUPLEX_UNKNOWN;
1145 pdata->phy.link = 0;
1147 pdata->phy.pause_autoneg = pdata->pause_autoneg;
1148 pdata->phy.tx_pause = pdata->tx_pause;
1149 pdata->phy.rx_pause = pdata->rx_pause;
1151 /* Fix up Flow Control advertising */
1152 pdata->phy.advertising &= ~ADVERTISED_Pause;
1153 pdata->phy.advertising &= ~ADVERTISED_Asym_Pause;
1155 if (pdata->rx_pause) {
1156 pdata->phy.advertising |= ADVERTISED_Pause;
1157 pdata->phy.advertising |= ADVERTISED_Asym_Pause;
1160 if (pdata->tx_pause)
1161 pdata->phy.advertising ^= ADVERTISED_Asym_Pause;
1164 void xgbe_init_function_ptrs_phy(struct xgbe_phy_if *phy_if)
1166 phy_if->phy_init = xgbe_phy_init;
1168 phy_if->phy_reset = xgbe_phy_reset;
1169 phy_if->phy_start = xgbe_phy_start;
1170 phy_if->phy_stop = xgbe_phy_stop;
1172 phy_if->phy_status = xgbe_phy_status;
1173 phy_if->phy_config_aneg = xgbe_phy_config_aneg;