2 * AMD 10Gb Ethernet driver
4 * This file is available to you under your choice of the following two
9 * Copyright (c) 2014 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 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 <linux/spinlock.h>
118 #include <linux/phy.h>
119 #include <linux/net_tstamp.h>
122 #include "xgbe-common.h"
125 char stat_string
[ETH_GSTRING_LEN
];
130 #define XGMAC_MMC_STAT(_string, _var) \
132 FIELD_SIZEOF(struct xgbe_mmc_stats, _var), \
133 offsetof(struct xgbe_prv_data, mmc_stats._var), \
136 static const struct xgbe_stats xgbe_gstring_stats
[] = {
137 XGMAC_MMC_STAT("tx_bytes", txoctetcount_gb
),
138 XGMAC_MMC_STAT("tx_packets", txframecount_gb
),
139 XGMAC_MMC_STAT("tx_unicast_packets", txunicastframes_gb
),
140 XGMAC_MMC_STAT("tx_broadcast_packets", txbroadcastframes_gb
),
141 XGMAC_MMC_STAT("tx_multicast_packets", txmulticastframes_gb
),
142 XGMAC_MMC_STAT("tx_vlan_packets", txvlanframes_g
),
143 XGMAC_MMC_STAT("tx_64_byte_packets", tx64octets_gb
),
144 XGMAC_MMC_STAT("tx_65_to_127_byte_packets", tx65to127octets_gb
),
145 XGMAC_MMC_STAT("tx_128_to_255_byte_packets", tx128to255octets_gb
),
146 XGMAC_MMC_STAT("tx_256_to_511_byte_packets", tx256to511octets_gb
),
147 XGMAC_MMC_STAT("tx_512_to_1023_byte_packets", tx512to1023octets_gb
),
148 XGMAC_MMC_STAT("tx_1024_to_max_byte_packets", tx1024tomaxoctets_gb
),
149 XGMAC_MMC_STAT("tx_underflow_errors", txunderflowerror
),
150 XGMAC_MMC_STAT("tx_pause_frames", txpauseframes
),
152 XGMAC_MMC_STAT("rx_bytes", rxoctetcount_gb
),
153 XGMAC_MMC_STAT("rx_packets", rxframecount_gb
),
154 XGMAC_MMC_STAT("rx_unicast_packets", rxunicastframes_g
),
155 XGMAC_MMC_STAT("rx_broadcast_packets", rxbroadcastframes_g
),
156 XGMAC_MMC_STAT("rx_multicast_packets", rxmulticastframes_g
),
157 XGMAC_MMC_STAT("rx_vlan_packets", rxvlanframes_gb
),
158 XGMAC_MMC_STAT("rx_64_byte_packets", rx64octets_gb
),
159 XGMAC_MMC_STAT("rx_65_to_127_byte_packets", rx65to127octets_gb
),
160 XGMAC_MMC_STAT("rx_128_to_255_byte_packets", rx128to255octets_gb
),
161 XGMAC_MMC_STAT("rx_256_to_511_byte_packets", rx256to511octets_gb
),
162 XGMAC_MMC_STAT("rx_512_to_1023_byte_packets", rx512to1023octets_gb
),
163 XGMAC_MMC_STAT("rx_1024_to_max_byte_packets", rx1024tomaxoctets_gb
),
164 XGMAC_MMC_STAT("rx_undersize_packets", rxundersize_g
),
165 XGMAC_MMC_STAT("rx_oversize_packets", rxoversize_g
),
166 XGMAC_MMC_STAT("rx_crc_errors", rxcrcerror
),
167 XGMAC_MMC_STAT("rx_crc_errors_small_packets", rxrunterror
),
168 XGMAC_MMC_STAT("rx_crc_errors_giant_packets", rxjabbererror
),
169 XGMAC_MMC_STAT("rx_length_errors", rxlengtherror
),
170 XGMAC_MMC_STAT("rx_out_of_range_errors", rxoutofrangetype
),
171 XGMAC_MMC_STAT("rx_fifo_overflow_errors", rxfifooverflow
),
172 XGMAC_MMC_STAT("rx_watchdog_errors", rxwatchdogerror
),
173 XGMAC_MMC_STAT("rx_pause_frames", rxpauseframes
),
176 #define XGBE_STATS_COUNT ARRAY_SIZE(xgbe_gstring_stats)
178 static void xgbe_get_strings(struct net_device
*netdev
, u32 stringset
, u8
*data
)
182 DBGPR("-->%s\n", __func__
);
186 for (i
= 0; i
< XGBE_STATS_COUNT
; i
++) {
187 memcpy(data
, xgbe_gstring_stats
[i
].stat_string
,
189 data
+= ETH_GSTRING_LEN
;
194 DBGPR("<--%s\n", __func__
);
197 static void xgbe_get_ethtool_stats(struct net_device
*netdev
,
198 struct ethtool_stats
*stats
, u64
*data
)
200 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
204 DBGPR("-->%s\n", __func__
);
206 pdata
->hw_if
.read_mmc_stats(pdata
);
207 for (i
= 0; i
< XGBE_STATS_COUNT
; i
++) {
208 stat
= (u8
*)pdata
+ xgbe_gstring_stats
[i
].stat_offset
;
209 *data
++ = *(u64
*)stat
;
212 DBGPR("<--%s\n", __func__
);
215 static int xgbe_get_sset_count(struct net_device
*netdev
, int stringset
)
219 DBGPR("-->%s\n", __func__
);
223 ret
= XGBE_STATS_COUNT
;
230 DBGPR("<--%s\n", __func__
);
235 static void xgbe_get_pauseparam(struct net_device
*netdev
,
236 struct ethtool_pauseparam
*pause
)
238 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
240 DBGPR("-->xgbe_get_pauseparam\n");
242 pause
->autoneg
= pdata
->pause_autoneg
;
243 pause
->tx_pause
= pdata
->tx_pause
;
244 pause
->rx_pause
= pdata
->rx_pause
;
246 DBGPR("<--xgbe_get_pauseparam\n");
249 static int xgbe_set_pauseparam(struct net_device
*netdev
,
250 struct ethtool_pauseparam
*pause
)
252 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
253 struct phy_device
*phydev
= pdata
->phydev
;
256 DBGPR("-->xgbe_set_pauseparam\n");
258 DBGPR(" autoneg = %d, tx_pause = %d, rx_pause = %d\n",
259 pause
->autoneg
, pause
->tx_pause
, pause
->rx_pause
);
261 pdata
->pause_autoneg
= pause
->autoneg
;
262 if (pause
->autoneg
) {
263 phydev
->advertising
|= ADVERTISED_Pause
;
264 phydev
->advertising
|= ADVERTISED_Asym_Pause
;
267 phydev
->advertising
&= ~ADVERTISED_Pause
;
268 phydev
->advertising
&= ~ADVERTISED_Asym_Pause
;
270 pdata
->tx_pause
= pause
->tx_pause
;
271 pdata
->rx_pause
= pause
->rx_pause
;
274 if (netif_running(netdev
))
275 ret
= phy_start_aneg(phydev
);
277 DBGPR("<--xgbe_set_pauseparam\n");
282 static int xgbe_get_settings(struct net_device
*netdev
,
283 struct ethtool_cmd
*cmd
)
285 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
288 DBGPR("-->xgbe_get_settings\n");
293 ret
= phy_ethtool_gset(pdata
->phydev
, cmd
);
294 cmd
->transceiver
= XCVR_EXTERNAL
;
296 DBGPR("<--xgbe_get_settings\n");
301 static int xgbe_set_settings(struct net_device
*netdev
,
302 struct ethtool_cmd
*cmd
)
304 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
305 struct phy_device
*phydev
= pdata
->phydev
;
309 DBGPR("-->xgbe_set_settings\n");
314 speed
= ethtool_cmd_speed(cmd
);
316 if (cmd
->phy_address
!= phydev
->addr
)
319 if ((cmd
->autoneg
!= AUTONEG_ENABLE
) &&
320 (cmd
->autoneg
!= AUTONEG_DISABLE
))
323 if (cmd
->autoneg
== AUTONEG_DISABLE
) {
333 if (cmd
->duplex
!= DUPLEX_FULL
)
337 cmd
->advertising
&= phydev
->supported
;
338 if ((cmd
->autoneg
== AUTONEG_ENABLE
) && !cmd
->advertising
)
342 phydev
->autoneg
= cmd
->autoneg
;
343 phydev
->speed
= speed
;
344 phydev
->duplex
= cmd
->duplex
;
345 phydev
->advertising
= cmd
->advertising
;
347 if (cmd
->autoneg
== AUTONEG_ENABLE
)
348 phydev
->advertising
|= ADVERTISED_Autoneg
;
350 phydev
->advertising
&= ~ADVERTISED_Autoneg
;
352 if (netif_running(netdev
))
353 ret
= phy_start_aneg(phydev
);
355 DBGPR("<--xgbe_set_settings\n");
360 static void xgbe_get_drvinfo(struct net_device
*netdev
,
361 struct ethtool_drvinfo
*drvinfo
)
363 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
364 struct xgbe_hw_features
*hw_feat
= &pdata
->hw_feat
;
366 strlcpy(drvinfo
->driver
, XGBE_DRV_NAME
, sizeof(drvinfo
->driver
));
367 strlcpy(drvinfo
->version
, XGBE_DRV_VERSION
, sizeof(drvinfo
->version
));
368 strlcpy(drvinfo
->bus_info
, dev_name(pdata
->dev
),
369 sizeof(drvinfo
->bus_info
));
370 snprintf(drvinfo
->fw_version
, sizeof(drvinfo
->fw_version
), "%d.%d.%d",
371 XGMAC_GET_BITS(hw_feat
->version
, MAC_VR
, USERVER
),
372 XGMAC_GET_BITS(hw_feat
->version
, MAC_VR
, DEVID
),
373 XGMAC_GET_BITS(hw_feat
->version
, MAC_VR
, SNPSVER
));
374 drvinfo
->n_stats
= XGBE_STATS_COUNT
;
377 static int xgbe_get_coalesce(struct net_device
*netdev
,
378 struct ethtool_coalesce
*ec
)
380 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
381 struct xgbe_hw_if
*hw_if
= &pdata
->hw_if
;
384 DBGPR("-->xgbe_get_coalesce\n");
386 memset(ec
, 0, sizeof(struct ethtool_coalesce
));
388 riwt
= pdata
->rx_riwt
;
389 ec
->rx_coalesce_usecs
= hw_if
->riwt_to_usec(pdata
, riwt
);
390 ec
->rx_max_coalesced_frames
= pdata
->rx_frames
;
392 ec
->tx_coalesce_usecs
= pdata
->tx_usecs
;
393 ec
->tx_max_coalesced_frames
= pdata
->tx_frames
;
395 DBGPR("<--xgbe_get_coalesce\n");
400 static int xgbe_set_coalesce(struct net_device
*netdev
,
401 struct ethtool_coalesce
*ec
)
403 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
404 struct xgbe_hw_if
*hw_if
= &pdata
->hw_if
;
405 unsigned int rx_frames
, rx_riwt
, rx_usecs
;
406 unsigned int tx_frames
, tx_usecs
;
408 DBGPR("-->xgbe_set_coalesce\n");
410 /* Check for not supported parameters */
411 if ((ec
->rx_coalesce_usecs_irq
) ||
412 (ec
->rx_max_coalesced_frames_irq
) ||
413 (ec
->tx_coalesce_usecs_irq
) ||
414 (ec
->tx_max_coalesced_frames_irq
) ||
415 (ec
->stats_block_coalesce_usecs
) ||
416 (ec
->use_adaptive_rx_coalesce
) ||
417 (ec
->use_adaptive_tx_coalesce
) ||
418 (ec
->pkt_rate_low
) ||
419 (ec
->rx_coalesce_usecs_low
) ||
420 (ec
->rx_max_coalesced_frames_low
) ||
421 (ec
->tx_coalesce_usecs_low
) ||
422 (ec
->tx_max_coalesced_frames_low
) ||
423 (ec
->pkt_rate_high
) ||
424 (ec
->rx_coalesce_usecs_high
) ||
425 (ec
->rx_max_coalesced_frames_high
) ||
426 (ec
->tx_coalesce_usecs_high
) ||
427 (ec
->tx_max_coalesced_frames_high
) ||
428 (ec
->rate_sample_interval
))
431 /* Can only change rx-frames when interface is down (see
432 * rx_descriptor_init in xgbe-dev.c)
434 rx_frames
= pdata
->rx_frames
;
435 if (rx_frames
!= ec
->rx_max_coalesced_frames
&& netif_running(netdev
)) {
437 "interface must be down to change rx-frames\n");
441 rx_riwt
= hw_if
->usec_to_riwt(pdata
, ec
->rx_coalesce_usecs
);
442 rx_frames
= ec
->rx_max_coalesced_frames
;
444 /* Use smallest possible value if conversion resulted in zero */
445 if (ec
->rx_coalesce_usecs
&& !rx_riwt
)
448 /* Check the bounds of values for Rx */
449 if (rx_riwt
> XGMAC_MAX_DMA_RIWT
) {
450 rx_usecs
= hw_if
->riwt_to_usec(pdata
, XGMAC_MAX_DMA_RIWT
);
451 netdev_alert(netdev
, "rx-usec is limited to %d usecs\n",
455 if (rx_frames
> pdata
->rx_desc_count
) {
456 netdev_alert(netdev
, "rx-frames is limited to %d frames\n",
457 pdata
->rx_desc_count
);
461 tx_usecs
= ec
->tx_coalesce_usecs
;
462 tx_frames
= ec
->tx_max_coalesced_frames
;
464 /* Check the bounds of values for Tx */
465 if (tx_frames
> pdata
->tx_desc_count
) {
466 netdev_alert(netdev
, "tx-frames is limited to %d frames\n",
467 pdata
->tx_desc_count
);
471 pdata
->rx_riwt
= rx_riwt
;
472 pdata
->rx_frames
= rx_frames
;
473 hw_if
->config_rx_coalesce(pdata
);
475 pdata
->tx_usecs
= tx_usecs
;
476 pdata
->tx_frames
= tx_frames
;
477 hw_if
->config_tx_coalesce(pdata
);
479 DBGPR("<--xgbe_set_coalesce\n");
484 static int xgbe_get_ts_info(struct net_device
*netdev
,
485 struct ethtool_ts_info
*ts_info
)
487 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
489 ts_info
->so_timestamping
= SOF_TIMESTAMPING_TX_SOFTWARE
|
490 SOF_TIMESTAMPING_RX_SOFTWARE
|
491 SOF_TIMESTAMPING_SOFTWARE
|
492 SOF_TIMESTAMPING_TX_HARDWARE
|
493 SOF_TIMESTAMPING_RX_HARDWARE
|
494 SOF_TIMESTAMPING_RAW_HARDWARE
;
496 if (pdata
->ptp_clock
)
497 ts_info
->phc_index
= ptp_clock_index(pdata
->ptp_clock
);
499 ts_info
->phc_index
= -1;
501 ts_info
->tx_types
= (1 << HWTSTAMP_TX_OFF
) | (1 << HWTSTAMP_TX_ON
);
502 ts_info
->rx_filters
= (1 << HWTSTAMP_FILTER_NONE
) |
503 (1 << HWTSTAMP_FILTER_PTP_V1_L4_EVENT
) |
504 (1 << HWTSTAMP_FILTER_PTP_V1_L4_SYNC
) |
505 (1 << HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ
) |
506 (1 << HWTSTAMP_FILTER_PTP_V2_L4_EVENT
) |
507 (1 << HWTSTAMP_FILTER_PTP_V2_L4_SYNC
) |
508 (1 << HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ
) |
509 (1 << HWTSTAMP_FILTER_PTP_V2_EVENT
) |
510 (1 << HWTSTAMP_FILTER_PTP_V2_SYNC
) |
511 (1 << HWTSTAMP_FILTER_PTP_V2_DELAY_REQ
) |
512 (1 << HWTSTAMP_FILTER_ALL
);
517 static const struct ethtool_ops xgbe_ethtool_ops
= {
518 .get_settings
= xgbe_get_settings
,
519 .set_settings
= xgbe_set_settings
,
520 .get_drvinfo
= xgbe_get_drvinfo
,
521 .get_link
= ethtool_op_get_link
,
522 .get_coalesce
= xgbe_get_coalesce
,
523 .set_coalesce
= xgbe_set_coalesce
,
524 .get_pauseparam
= xgbe_get_pauseparam
,
525 .set_pauseparam
= xgbe_set_pauseparam
,
526 .get_strings
= xgbe_get_strings
,
527 .get_ethtool_stats
= xgbe_get_ethtool_stats
,
528 .get_sset_count
= xgbe_get_sset_count
,
529 .get_ts_info
= xgbe_get_ts_info
,
532 struct ethtool_ops
*xgbe_get_ethtool_ops(void)
534 return (struct ethtool_ops
*)&xgbe_ethtool_ops
;