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
);
295 DBGPR("<--xgbe_get_settings\n");
300 static int xgbe_set_settings(struct net_device
*netdev
,
301 struct ethtool_cmd
*cmd
)
303 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
304 struct phy_device
*phydev
= pdata
->phydev
;
308 DBGPR("-->xgbe_set_settings\n");
313 speed
= ethtool_cmd_speed(cmd
);
315 if (cmd
->phy_address
!= phydev
->addr
)
318 if ((cmd
->autoneg
!= AUTONEG_ENABLE
) &&
319 (cmd
->autoneg
!= AUTONEG_DISABLE
))
322 if (cmd
->autoneg
== AUTONEG_DISABLE
) {
332 if (cmd
->duplex
!= DUPLEX_FULL
)
336 cmd
->advertising
&= phydev
->supported
;
337 if ((cmd
->autoneg
== AUTONEG_ENABLE
) && !cmd
->advertising
)
341 phydev
->autoneg
= cmd
->autoneg
;
342 phydev
->speed
= speed
;
343 phydev
->duplex
= cmd
->duplex
;
344 phydev
->advertising
= cmd
->advertising
;
346 if (cmd
->autoneg
== AUTONEG_ENABLE
)
347 phydev
->advertising
|= ADVERTISED_Autoneg
;
349 phydev
->advertising
&= ~ADVERTISED_Autoneg
;
351 if (netif_running(netdev
))
352 ret
= phy_start_aneg(phydev
);
354 DBGPR("<--xgbe_set_settings\n");
359 static void xgbe_get_drvinfo(struct net_device
*netdev
,
360 struct ethtool_drvinfo
*drvinfo
)
362 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
363 struct xgbe_hw_features
*hw_feat
= &pdata
->hw_feat
;
365 strlcpy(drvinfo
->driver
, XGBE_DRV_NAME
, sizeof(drvinfo
->driver
));
366 strlcpy(drvinfo
->version
, XGBE_DRV_VERSION
, sizeof(drvinfo
->version
));
367 strlcpy(drvinfo
->bus_info
, dev_name(pdata
->dev
),
368 sizeof(drvinfo
->bus_info
));
369 snprintf(drvinfo
->fw_version
, sizeof(drvinfo
->fw_version
), "%d.%d.%d",
370 XGMAC_GET_BITS(hw_feat
->version
, MAC_VR
, USERVER
),
371 XGMAC_GET_BITS(hw_feat
->version
, MAC_VR
, DEVID
),
372 XGMAC_GET_BITS(hw_feat
->version
, MAC_VR
, SNPSVER
));
373 drvinfo
->n_stats
= XGBE_STATS_COUNT
;
376 static int xgbe_get_coalesce(struct net_device
*netdev
,
377 struct ethtool_coalesce
*ec
)
379 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
380 struct xgbe_hw_if
*hw_if
= &pdata
->hw_if
;
383 DBGPR("-->xgbe_get_coalesce\n");
385 memset(ec
, 0, sizeof(struct ethtool_coalesce
));
387 riwt
= pdata
->rx_riwt
;
388 ec
->rx_coalesce_usecs
= hw_if
->riwt_to_usec(pdata
, riwt
);
389 ec
->rx_max_coalesced_frames
= pdata
->rx_frames
;
391 ec
->tx_coalesce_usecs
= pdata
->tx_usecs
;
392 ec
->tx_max_coalesced_frames
= pdata
->tx_frames
;
394 DBGPR("<--xgbe_get_coalesce\n");
399 static int xgbe_set_coalesce(struct net_device
*netdev
,
400 struct ethtool_coalesce
*ec
)
402 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
403 struct xgbe_hw_if
*hw_if
= &pdata
->hw_if
;
404 unsigned int rx_frames
, rx_riwt
, rx_usecs
;
405 unsigned int tx_frames
, tx_usecs
;
407 DBGPR("-->xgbe_set_coalesce\n");
409 /* Check for not supported parameters */
410 if ((ec
->rx_coalesce_usecs_irq
) ||
411 (ec
->rx_max_coalesced_frames_irq
) ||
412 (ec
->tx_coalesce_usecs_irq
) ||
413 (ec
->tx_max_coalesced_frames_irq
) ||
414 (ec
->stats_block_coalesce_usecs
) ||
415 (ec
->use_adaptive_rx_coalesce
) ||
416 (ec
->use_adaptive_tx_coalesce
) ||
417 (ec
->pkt_rate_low
) ||
418 (ec
->rx_coalesce_usecs_low
) ||
419 (ec
->rx_max_coalesced_frames_low
) ||
420 (ec
->tx_coalesce_usecs_low
) ||
421 (ec
->tx_max_coalesced_frames_low
) ||
422 (ec
->pkt_rate_high
) ||
423 (ec
->rx_coalesce_usecs_high
) ||
424 (ec
->rx_max_coalesced_frames_high
) ||
425 (ec
->tx_coalesce_usecs_high
) ||
426 (ec
->tx_max_coalesced_frames_high
) ||
427 (ec
->rate_sample_interval
))
430 /* Can only change rx-frames when interface is down (see
431 * rx_descriptor_init in xgbe-dev.c)
433 rx_frames
= pdata
->rx_frames
;
434 if (rx_frames
!= ec
->rx_max_coalesced_frames
&& netif_running(netdev
)) {
436 "interface must be down to change rx-frames\n");
440 rx_riwt
= hw_if
->usec_to_riwt(pdata
, ec
->rx_coalesce_usecs
);
441 rx_frames
= ec
->rx_max_coalesced_frames
;
443 /* Use smallest possible value if conversion resulted in zero */
444 if (ec
->rx_coalesce_usecs
&& !rx_riwt
)
447 /* Check the bounds of values for Rx */
448 if (rx_riwt
> XGMAC_MAX_DMA_RIWT
) {
449 rx_usecs
= hw_if
->riwt_to_usec(pdata
, XGMAC_MAX_DMA_RIWT
);
450 netdev_alert(netdev
, "rx-usec is limited to %d usecs\n",
454 if (rx_frames
> pdata
->rx_desc_count
) {
455 netdev_alert(netdev
, "rx-frames is limited to %d frames\n",
456 pdata
->rx_desc_count
);
460 tx_usecs
= ec
->tx_coalesce_usecs
;
461 tx_frames
= ec
->tx_max_coalesced_frames
;
463 /* Check the bounds of values for Tx */
464 if (tx_frames
> pdata
->tx_desc_count
) {
465 netdev_alert(netdev
, "tx-frames is limited to %d frames\n",
466 pdata
->tx_desc_count
);
470 pdata
->rx_riwt
= rx_riwt
;
471 pdata
->rx_frames
= rx_frames
;
472 hw_if
->config_rx_coalesce(pdata
);
474 pdata
->tx_usecs
= tx_usecs
;
475 pdata
->tx_frames
= tx_frames
;
476 hw_if
->config_tx_coalesce(pdata
);
478 DBGPR("<--xgbe_set_coalesce\n");
483 static int xgbe_get_rxnfc(struct net_device
*netdev
,
484 struct ethtool_rxnfc
*rxnfc
, u32
*rule_locs
)
486 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
488 switch (rxnfc
->cmd
) {
489 case ETHTOOL_GRXRINGS
:
490 rxnfc
->data
= pdata
->rx_ring_count
;
499 static u32
xgbe_get_rxfh_key_size(struct net_device
*netdev
)
501 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
503 return sizeof(pdata
->rss_key
);
506 static u32
xgbe_get_rxfh_indir_size(struct net_device
*netdev
)
508 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
510 return ARRAY_SIZE(pdata
->rss_table
);
513 static int xgbe_get_rxfh(struct net_device
*netdev
, u32
*indir
, u8
*key
,
516 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
520 for (i
= 0; i
< ARRAY_SIZE(pdata
->rss_table
); i
++)
521 indir
[i
] = XGMAC_GET_BITS(pdata
->rss_table
[i
],
526 memcpy(key
, pdata
->rss_key
, sizeof(pdata
->rss_key
));
529 *hfunc
= ETH_RSS_HASH_TOP
;
534 static int xgbe_set_rxfh(struct net_device
*netdev
, const u32
*indir
,
535 const u8
*key
, const u8 hfunc
)
537 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
538 struct xgbe_hw_if
*hw_if
= &pdata
->hw_if
;
541 if (hfunc
!= ETH_RSS_HASH_NO_CHANGE
&& hfunc
!= ETH_RSS_HASH_TOP
)
545 ret
= hw_if
->set_rss_lookup_table(pdata
, indir
);
551 ret
= hw_if
->set_rss_hash_key(pdata
, key
);
559 static int xgbe_get_ts_info(struct net_device
*netdev
,
560 struct ethtool_ts_info
*ts_info
)
562 struct xgbe_prv_data
*pdata
= netdev_priv(netdev
);
564 ts_info
->so_timestamping
= SOF_TIMESTAMPING_TX_SOFTWARE
|
565 SOF_TIMESTAMPING_RX_SOFTWARE
|
566 SOF_TIMESTAMPING_SOFTWARE
|
567 SOF_TIMESTAMPING_TX_HARDWARE
|
568 SOF_TIMESTAMPING_RX_HARDWARE
|
569 SOF_TIMESTAMPING_RAW_HARDWARE
;
571 if (pdata
->ptp_clock
)
572 ts_info
->phc_index
= ptp_clock_index(pdata
->ptp_clock
);
574 ts_info
->phc_index
= -1;
576 ts_info
->tx_types
= (1 << HWTSTAMP_TX_OFF
) | (1 << HWTSTAMP_TX_ON
);
577 ts_info
->rx_filters
= (1 << HWTSTAMP_FILTER_NONE
) |
578 (1 << HWTSTAMP_FILTER_PTP_V1_L4_EVENT
) |
579 (1 << HWTSTAMP_FILTER_PTP_V1_L4_SYNC
) |
580 (1 << HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ
) |
581 (1 << HWTSTAMP_FILTER_PTP_V2_L4_EVENT
) |
582 (1 << HWTSTAMP_FILTER_PTP_V2_L4_SYNC
) |
583 (1 << HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ
) |
584 (1 << HWTSTAMP_FILTER_PTP_V2_EVENT
) |
585 (1 << HWTSTAMP_FILTER_PTP_V2_SYNC
) |
586 (1 << HWTSTAMP_FILTER_PTP_V2_DELAY_REQ
) |
587 (1 << HWTSTAMP_FILTER_ALL
);
592 static const struct ethtool_ops xgbe_ethtool_ops
= {
593 .get_settings
= xgbe_get_settings
,
594 .set_settings
= xgbe_set_settings
,
595 .get_drvinfo
= xgbe_get_drvinfo
,
596 .get_link
= ethtool_op_get_link
,
597 .get_coalesce
= xgbe_get_coalesce
,
598 .set_coalesce
= xgbe_set_coalesce
,
599 .get_pauseparam
= xgbe_get_pauseparam
,
600 .set_pauseparam
= xgbe_set_pauseparam
,
601 .get_strings
= xgbe_get_strings
,
602 .get_ethtool_stats
= xgbe_get_ethtool_stats
,
603 .get_sset_count
= xgbe_get_sset_count
,
604 .get_rxnfc
= xgbe_get_rxnfc
,
605 .get_rxfh_key_size
= xgbe_get_rxfh_key_size
,
606 .get_rxfh_indir_size
= xgbe_get_rxfh_indir_size
,
607 .get_rxfh
= xgbe_get_rxfh
,
608 .set_rxfh
= xgbe_set_rxfh
,
609 .get_ts_info
= xgbe_get_ts_info
,
612 struct ethtool_ops
*xgbe_get_ethtool_ops(void)
614 return (struct ethtool_ops
*)&xgbe_ethtool_ops
;