projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
amd-xgbe: Remove Tx coalescing
[deliverable/linux.git] / drivers / net / ethernet / amd / xgbe / xgbe-ethtool.c
CommitLineData
c5aa9e3b
LT		 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 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 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/spinlock.h>
118#include <linux/phy.h>
23e4eef7 119#include <linux/net_tstamp.h>
c5aa9e3b
LT		 120
121#include "xgbe.h"
122#include "xgbe-common.h"
123
c5aa9e3b
LT		 124struct xgbe_stats {
125 char stat_string[ETH_GSTRING_LEN];
126 int stat_size;
127 int stat_offset;
128};
129
130#define XGMAC_MMC_STAT(_string, _var) \
131 { _string, \
132 FIELD_SIZEOF(struct xgbe_mmc_stats, _var), \
133 offsetof(struct xgbe_prv_data, mmc_stats._var), \
134 }
135
136static 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),
151
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),
174};
a2ea14d7 175
c5aa9e3b
LT		 176#define XGBE_STATS_COUNT ARRAY_SIZE(xgbe_gstring_stats)
177
178static void xgbe_get_strings(struct net_device *netdev, u32 stringset, u8 *data)
179{
180 int i;
181
182 DBGPR("-->%s\n", __func__);
183
184 switch (stringset) {
185 case ETH_SS_STATS:
186 for (i = 0; i < XGBE_STATS_COUNT; i++) {
187 memcpy(data, xgbe_gstring_stats[i].stat_string,
188 ETH_GSTRING_LEN);
189 data += ETH_GSTRING_LEN;
190 }
191 break;
192 }
193
194 DBGPR("<--%s\n", __func__);
195}
196
197static void xgbe_get_ethtool_stats(struct net_device *netdev,
198 struct ethtool_stats *stats, u64 *data)
199{
200 struct xgbe_prv_data *pdata = netdev_priv(netdev);
201 u8 *stat;
202 int i;
203
204 DBGPR("-->%s\n", __func__);
205
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;
210 }
211
212 DBGPR("<--%s\n", __func__);
213}
214
215static int xgbe_get_sset_count(struct net_device *netdev, int stringset)
216{
217 int ret;
218
219 DBGPR("-->%s\n", __func__);
220
221 switch (stringset) {
222 case ETH_SS_STATS:
223 ret = XGBE_STATS_COUNT;
224 break;
225
226 default:
227 ret = -EOPNOTSUPP;
228 }
229
230 DBGPR("<--%s\n", __func__);
231
232 return ret;
233}
234
235static void xgbe_get_pauseparam(struct net_device *netdev,
236 struct ethtool_pauseparam *pause)
237{
238 struct xgbe_prv_data *pdata = netdev_priv(netdev);
239
240 DBGPR("-->xgbe_get_pauseparam\n");
241
242 pause->autoneg = pdata->pause_autoneg;
243 pause->tx_pause = pdata->tx_pause;
244 pause->rx_pause = pdata->rx_pause;
245
246 DBGPR("<--xgbe_get_pauseparam\n");
247}
248
249static int xgbe_set_pauseparam(struct net_device *netdev,
250 struct ethtool_pauseparam *pause)
251{
252 struct xgbe_prv_data *pdata = netdev_priv(netdev);
253 struct phy_device *phydev = pdata->phydev;
254 int ret = 0;
255
256 DBGPR("-->xgbe_set_pauseparam\n");
257
258 DBGPR(" autoneg = %d, tx_pause = %d, rx_pause = %d\n",
259 pause->autoneg, pause->tx_pause, pause->rx_pause);
260
261 pdata->pause_autoneg = pause->autoneg;
262 if (pause->autoneg) {
263 phydev->advertising |= ADVERTISED_Pause;
264 phydev->advertising |= ADVERTISED_Asym_Pause;
265
266 } else {
267 phydev->advertising &= ~ADVERTISED_Pause;
268 phydev->advertising &= ~ADVERTISED_Asym_Pause;
269
270 pdata->tx_pause = pause->tx_pause;
271 pdata->rx_pause = pause->rx_pause;
272 }
273
274 if (netif_running(netdev))
275 ret = phy_start_aneg(phydev);
276
277 DBGPR("<--xgbe_set_pauseparam\n");
278
279 return ret;
280}
281
282static int xgbe_get_settings(struct net_device *netdev,
283 struct ethtool_cmd *cmd)
284{
285 struct xgbe_prv_data *pdata = netdev_priv(netdev);
286 int ret;
287
288 DBGPR("-->xgbe_get_settings\n");
289
290 if (!pdata->phydev)
291 return -ENODEV;
292
c5aa9e3b 293 ret = phy_ethtool_gset(pdata->phydev, cmd);
c5aa9e3b 294
c5aa9e3b
LT		 295 DBGPR("<--xgbe_get_settings\n");
296
297 return ret;
298}
299
300static int xgbe_set_settings(struct net_device *netdev,
301 struct ethtool_cmd *cmd)
302{
303 struct xgbe_prv_data *pdata = netdev_priv(netdev);
304 struct phy_device *phydev = pdata->phydev;
305 u32 speed;
306 int ret;
307
308 DBGPR("-->xgbe_set_settings\n");
309
310 if (!pdata->phydev)
311 return -ENODEV;
312
c5aa9e3b
LT		 313 speed = ethtool_cmd_speed(cmd);
314
c5aa9e3b 315 if (cmd->phy_address != phydev->addr)
8c43a2cc 316 return -EINVAL;
c5aa9e3b
LT		 317
318 if ((cmd->autoneg != AUTONEG_ENABLE) &&
319 (cmd->autoneg != AUTONEG_DISABLE))
8c43a2cc 320 return -EINVAL;
c5aa9e3b 321
f047604a
LT		 322 if (cmd->autoneg == AUTONEG_DISABLE) {
323 switch (speed) {
324 case SPEED_10000:
325 case SPEED_2500:
326 case SPEED_1000:
327 break;
328 default:
8c43a2cc 329 return -EINVAL;
f047604a
LT		 330 }
331
332 if (cmd->duplex != DUPLEX_FULL)
8c43a2cc 333 return -EINVAL;
f047604a 334 }
c5aa9e3b 335
c5aa9e3b
LT		 336 cmd->advertising &= phydev->supported;
337 if ((cmd->autoneg == AUTONEG_ENABLE) && !cmd->advertising)
8c43a2cc 338 return -EINVAL;
c5aa9e3b
LT		 339
340 ret = 0;
341 phydev->autoneg = cmd->autoneg;
342 phydev->speed = speed;
343 phydev->duplex = cmd->duplex;
344 phydev->advertising = cmd->advertising;
345
346 if (cmd->autoneg == AUTONEG_ENABLE)
347 phydev->advertising |= ADVERTISED_Autoneg;
348 else
349 phydev->advertising &= ~ADVERTISED_Autoneg;
350
351 if (netif_running(netdev))
352 ret = phy_start_aneg(phydev);
353
c5aa9e3b
LT		 354 DBGPR("<--xgbe_set_settings\n");
355
356 return ret;
357}
358
359static void xgbe_get_drvinfo(struct net_device *netdev,
360 struct ethtool_drvinfo *drvinfo)
361{
362 struct xgbe_prv_data *pdata = netdev_priv(netdev);
a9a4a2d9 363 struct xgbe_hw_features *hw_feat = &pdata->hw_feat;
c5aa9e3b
LT		 364
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",
a9a4a2d9
LT		 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));
c5aa9e3b
LT		 373 drvinfo->n_stats = XGBE_STATS_COUNT;
374}
375
376static int xgbe_get_coalesce(struct net_device *netdev,
377 struct ethtool_coalesce *ec)
378{
379 struct xgbe_prv_data *pdata = netdev_priv(netdev);
380 struct xgbe_hw_if *hw_if = &pdata->hw_if;
381 unsigned int riwt;
382
383 DBGPR("-->xgbe_get_coalesce\n");
384
385 memset(ec, 0, sizeof(struct ethtool_coalesce));
386
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;
390
c5aa9e3b
LT		 391 ec->tx_max_coalesced_frames = pdata->tx_frames;
392
393 DBGPR("<--xgbe_get_coalesce\n");
394
395 return 0;
396}
397
398static int xgbe_set_coalesce(struct net_device *netdev,
399 struct ethtool_coalesce *ec)
400{
401 struct xgbe_prv_data *pdata = netdev_priv(netdev);
402 struct xgbe_hw_if *hw_if = &pdata->hw_if;
403 unsigned int rx_frames, rx_riwt, rx_usecs;
c635eaac 404 unsigned int tx_frames;
c5aa9e3b
LT		 405
406 DBGPR("-->xgbe_set_coalesce\n");
407
408 /* Check for not supported parameters */
409 if ((ec->rx_coalesce_usecs_irq) ||
410 (ec->rx_max_coalesced_frames_irq) ||
c635eaac 411 (ec->tx_coalesce_usecs) ||
c5aa9e3b
LT		 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))
428 return -EOPNOTSUPP;
429
430 /* Can only change rx-frames when interface is down (see
431 * rx_descriptor_init in xgbe-dev.c)
432 */
433 rx_frames = pdata->rx_frames;
434 if (rx_frames != ec->rx_max_coalesced_frames && netif_running(netdev)) {
435 netdev_alert(netdev,
436 "interface must be down to change rx-frames\n");
437 return -EINVAL;
438 }
439
440 rx_riwt = hw_if->usec_to_riwt(pdata, ec->rx_coalesce_usecs);
441 rx_frames = ec->rx_max_coalesced_frames;
442
443 /* Use smallest possible value if conversion resulted in zero */
444 if (ec->rx_coalesce_usecs && !rx_riwt)
445 rx_riwt = 1;
446
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",
451 rx_usecs);
452 return -EINVAL;
453 }
4780b7ca 454 if (rx_frames > pdata->rx_desc_count) {
c5aa9e3b 455 netdev_alert(netdev, "rx-frames is limited to %d frames\n",
4780b7ca 456 pdata->rx_desc_count);
c5aa9e3b
LT		 457 return -EINVAL;
458 }
459
c5aa9e3b
LT		 460 tx_frames = ec->tx_max_coalesced_frames;
461
462 /* Check the bounds of values for Tx */
4780b7ca 463 if (tx_frames > pdata->tx_desc_count) {
c5aa9e3b 464 netdev_alert(netdev, "tx-frames is limited to %d frames\n",
4780b7ca 465 pdata->tx_desc_count);
c5aa9e3b
LT		 466 return -EINVAL;
467 }
468
469 pdata->rx_riwt = rx_riwt;
470 pdata->rx_frames = rx_frames;
471 hw_if->config_rx_coalesce(pdata);
472
c5aa9e3b
LT		 473 pdata->tx_frames = tx_frames;
474 hw_if->config_tx_coalesce(pdata);
475
476 DBGPR("<--xgbe_set_coalesce\n");
477
478 return 0;
479}
480
f6ac8628
LT		 481static int xgbe_get_rxnfc(struct net_device *netdev,
482 struct ethtool_rxnfc *rxnfc, u32 *rule_locs)
483{
484 struct xgbe_prv_data *pdata = netdev_priv(netdev);
485
486 switch (rxnfc->cmd) {
487 case ETHTOOL_GRXRINGS:
488 rxnfc->data = pdata->rx_ring_count;
489 break;
490 default:
491 return -EOPNOTSUPP;
492 }
493
494 return 0;
495}
496
497static u32 xgbe_get_rxfh_key_size(struct net_device *netdev)
498{
499 struct xgbe_prv_data *pdata = netdev_priv(netdev);
500
501 return sizeof(pdata->rss_key);
502}
503
504static u32 xgbe_get_rxfh_indir_size(struct net_device *netdev)
505{
506 struct xgbe_prv_data *pdata = netdev_priv(netdev);
507
508 return ARRAY_SIZE(pdata->rss_table);
509}
510
892311f6
EP		 511static int xgbe_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key,
512 u8 *hfunc)
f6ac8628
LT		 513{
514 struct xgbe_prv_data *pdata = netdev_priv(netdev);
515 unsigned int i;
516
517 if (indir) {
518 for (i = 0; i < ARRAY_SIZE(pdata->rss_table); i++)
519 indir[i] = XGMAC_GET_BITS(pdata->rss_table[i],
520 MAC_RSSDR, DMCH);
521 }
522
523 if (key)
524 memcpy(key, pdata->rss_key, sizeof(pdata->rss_key));
525
892311f6
EP		 526 if (hfunc)
527 *hfunc = ETH_RSS_HASH_TOP;
528
f6ac8628
LT		 529 return 0;
530}
531
532static int xgbe_set_rxfh(struct net_device *netdev, const u32 *indir,
892311f6 533 const u8 *key, const u8 hfunc)
f6ac8628
LT		 534{
535 struct xgbe_prv_data *pdata = netdev_priv(netdev);
536 struct xgbe_hw_if *hw_if = &pdata->hw_if;
537 unsigned int ret;
538
892311f6
EP		 539 if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)
540 return -EOPNOTSUPP;
541
f6ac8628
LT		 542 if (indir) {
543 ret = hw_if->set_rss_lookup_table(pdata, indir);
544 if (ret)
545 return ret;
546 }
547
548 if (key) {
549 ret = hw_if->set_rss_hash_key(pdata, key);
550 if (ret)
551 return ret;
552 }
553
554 return 0;
555}
556
23e4eef7
LT		 557static int xgbe_get_ts_info(struct net_device *netdev,
558 struct ethtool_ts_info *ts_info)
559{
560 struct xgbe_prv_data *pdata = netdev_priv(netdev);
561
562 ts_info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
563 SOF_TIMESTAMPING_RX_SOFTWARE |
564 SOF_TIMESTAMPING_SOFTWARE |
565 SOF_TIMESTAMPING_TX_HARDWARE |
566 SOF_TIMESTAMPING_RX_HARDWARE |
567 SOF_TIMESTAMPING_RAW_HARDWARE;
568
569 if (pdata->ptp_clock)
570 ts_info->phc_index = ptp_clock_index(pdata->ptp_clock);
571 else
572 ts_info->phc_index = -1;
573
574 ts_info->tx_types = (1 << HWTSTAMP_TX_OFF) | (1 << HWTSTAMP_TX_ON);
575 ts_info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
576 (1 << HWTSTAMP_FILTER_PTP_V1_L4_EVENT) |
577 (1 << HWTSTAMP_FILTER_PTP_V1_L4_SYNC) |
578 (1 << HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ) |
579 (1 << HWTSTAMP_FILTER_PTP_V2_L4_EVENT) |
580 (1 << HWTSTAMP_FILTER_PTP_V2_L4_SYNC) |
581 (1 << HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ) |
582 (1 << HWTSTAMP_FILTER_PTP_V2_EVENT) |
583 (1 << HWTSTAMP_FILTER_PTP_V2_SYNC) |
584 (1 << HWTSTAMP_FILTER_PTP_V2_DELAY_REQ) |
585 (1 << HWTSTAMP_FILTER_ALL);
586
587 return 0;
588}
589
c5aa9e3b
LT		 590static const struct ethtool_ops xgbe_ethtool_ops = {
591 .get_settings = xgbe_get_settings,
592 .set_settings = xgbe_set_settings,
593 .get_drvinfo = xgbe_get_drvinfo,
594 .get_link = ethtool_op_get_link,
595 .get_coalesce = xgbe_get_coalesce,
596 .set_coalesce = xgbe_set_coalesce,
597 .get_pauseparam = xgbe_get_pauseparam,
598 .set_pauseparam = xgbe_set_pauseparam,
599 .get_strings = xgbe_get_strings,
600 .get_ethtool_stats = xgbe_get_ethtool_stats,
601 .get_sset_count = xgbe_get_sset_count,
f6ac8628
LT		 602 .get_rxnfc = xgbe_get_rxnfc,
603 .get_rxfh_key_size = xgbe_get_rxfh_key_size,
604 .get_rxfh_indir_size = xgbe_get_rxfh_indir_size,
605 .get_rxfh = xgbe_get_rxfh,
606 .set_rxfh = xgbe_set_rxfh,
23e4eef7 607 .get_ts_info = xgbe_get_ts_info,
c5aa9e3b
LT		 608};
609
610struct ethtool_ops *xgbe_get_ethtool_ops(void)
611{
612 return (struct ethtool_ops *)&xgbe_ethtool_ops;
613}
Linux kernel - Deliverables
This page took 0.139924 seconds and 5 git commands to generate.