mlx4_en: set number of rx rings used by RSS using ethtool
[linux-2.6.git] / drivers / net / ethernet / mellanox / mlx4 / en_ethtool.c
1 /*
2  * Copyright (c) 2007 Mellanox Technologies. All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  *
32  */
33
34 #include <linux/kernel.h>
35 #include <linux/ethtool.h>
36 #include <linux/netdevice.h>
37
38 #include "mlx4_en.h"
39 #include "en_port.h"
40
41
42 static void
43 mlx4_en_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
44 {
45         struct mlx4_en_priv *priv = netdev_priv(dev);
46         struct mlx4_en_dev *mdev = priv->mdev;
47
48         strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
49         strlcpy(drvinfo->version, DRV_VERSION " (" DRV_RELDATE ")",
50                 sizeof(drvinfo->version));
51         snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
52                 "%d.%d.%d",
53                 (u16) (mdev->dev->caps.fw_ver >> 32),
54                 (u16) ((mdev->dev->caps.fw_ver >> 16) & 0xffff),
55                 (u16) (mdev->dev->caps.fw_ver & 0xffff));
56         strlcpy(drvinfo->bus_info, pci_name(mdev->dev->pdev),
57                 sizeof(drvinfo->bus_info));
58         drvinfo->n_stats = 0;
59         drvinfo->regdump_len = 0;
60         drvinfo->eedump_len = 0;
61 }
62
63 static const char main_strings[][ETH_GSTRING_LEN] = {
64         "rx_packets", "tx_packets", "rx_bytes", "tx_bytes", "rx_errors",
65         "tx_errors", "rx_dropped", "tx_dropped", "multicast", "collisions",
66         "rx_length_errors", "rx_over_errors", "rx_crc_errors",
67         "rx_frame_errors", "rx_fifo_errors", "rx_missed_errors",
68         "tx_aborted_errors", "tx_carrier_errors", "tx_fifo_errors",
69         "tx_heartbeat_errors", "tx_window_errors",
70
71         /* port statistics */
72         "tso_packets",
73         "queue_stopped", "wake_queue", "tx_timeout", "rx_alloc_failed",
74         "rx_csum_good", "rx_csum_none", "tx_chksum_offload",
75
76         /* packet statistics */
77         "broadcast", "rx_prio_0", "rx_prio_1", "rx_prio_2", "rx_prio_3",
78         "rx_prio_4", "rx_prio_5", "rx_prio_6", "rx_prio_7", "tx_prio_0",
79         "tx_prio_1", "tx_prio_2", "tx_prio_3", "tx_prio_4", "tx_prio_5",
80         "tx_prio_6", "tx_prio_7",
81 };
82 #define NUM_MAIN_STATS  21
83 #define NUM_ALL_STATS   (NUM_MAIN_STATS + NUM_PORT_STATS + NUM_PKT_STATS + NUM_PERF_STATS)
84
85 static const char mlx4_en_test_names[][ETH_GSTRING_LEN]= {
86         "Interupt Test",
87         "Link Test",
88         "Speed Test",
89         "Register Test",
90         "Loopback Test",
91 };
92
93 static u32 mlx4_en_get_msglevel(struct net_device *dev)
94 {
95         return ((struct mlx4_en_priv *) netdev_priv(dev))->msg_enable;
96 }
97
98 static void mlx4_en_set_msglevel(struct net_device *dev, u32 val)
99 {
100         ((struct mlx4_en_priv *) netdev_priv(dev))->msg_enable = val;
101 }
102
103 static void mlx4_en_get_wol(struct net_device *netdev,
104                             struct ethtool_wolinfo *wol)
105 {
106         struct mlx4_en_priv *priv = netdev_priv(netdev);
107         int err = 0;
108         u64 config = 0;
109         u64 mask;
110
111         if ((priv->port < 1) || (priv->port > 2)) {
112                 en_err(priv, "Failed to get WoL information\n");
113                 return;
114         }
115
116         mask = (priv->port == 1) ? MLX4_DEV_CAP_FLAG_WOL_PORT1 :
117                 MLX4_DEV_CAP_FLAG_WOL_PORT2;
118
119         if (!(priv->mdev->dev->caps.flags & mask)) {
120                 wol->supported = 0;
121                 wol->wolopts = 0;
122                 return;
123         }
124
125         err = mlx4_wol_read(priv->mdev->dev, &config, priv->port);
126         if (err) {
127                 en_err(priv, "Failed to get WoL information\n");
128                 return;
129         }
130
131         if (config & MLX4_EN_WOL_MAGIC)
132                 wol->supported = WAKE_MAGIC;
133         else
134                 wol->supported = 0;
135
136         if (config & MLX4_EN_WOL_ENABLED)
137                 wol->wolopts = WAKE_MAGIC;
138         else
139                 wol->wolopts = 0;
140 }
141
142 static int mlx4_en_set_wol(struct net_device *netdev,
143                             struct ethtool_wolinfo *wol)
144 {
145         struct mlx4_en_priv *priv = netdev_priv(netdev);
146         u64 config = 0;
147         int err = 0;
148         u64 mask;
149
150         if ((priv->port < 1) || (priv->port > 2))
151                 return -EOPNOTSUPP;
152
153         mask = (priv->port == 1) ? MLX4_DEV_CAP_FLAG_WOL_PORT1 :
154                 MLX4_DEV_CAP_FLAG_WOL_PORT2;
155
156         if (!(priv->mdev->dev->caps.flags & mask))
157                 return -EOPNOTSUPP;
158
159         if (wol->supported & ~WAKE_MAGIC)
160                 return -EINVAL;
161
162         err = mlx4_wol_read(priv->mdev->dev, &config, priv->port);
163         if (err) {
164                 en_err(priv, "Failed to get WoL info, unable to modify\n");
165                 return err;
166         }
167
168         if (wol->wolopts & WAKE_MAGIC) {
169                 config |= MLX4_EN_WOL_DO_MODIFY | MLX4_EN_WOL_ENABLED |
170                                 MLX4_EN_WOL_MAGIC;
171         } else {
172                 config &= ~(MLX4_EN_WOL_ENABLED | MLX4_EN_WOL_MAGIC);
173                 config |= MLX4_EN_WOL_DO_MODIFY;
174         }
175
176         err = mlx4_wol_write(priv->mdev->dev, config, priv->port);
177         if (err)
178                 en_err(priv, "Failed to set WoL information\n");
179
180         return err;
181 }
182
183 static int mlx4_en_get_sset_count(struct net_device *dev, int sset)
184 {
185         struct mlx4_en_priv *priv = netdev_priv(dev);
186
187         switch (sset) {
188         case ETH_SS_STATS:
189                 return NUM_ALL_STATS +
190                         (priv->tx_ring_num + priv->rx_ring_num) * 2;
191         case ETH_SS_TEST:
192                 return MLX4_EN_NUM_SELF_TEST - !(priv->mdev->dev->caps.flags
193                                         & MLX4_DEV_CAP_FLAG_UC_LOOPBACK) * 2;
194         default:
195                 return -EOPNOTSUPP;
196         }
197 }
198
199 static void mlx4_en_get_ethtool_stats(struct net_device *dev,
200                 struct ethtool_stats *stats, uint64_t *data)
201 {
202         struct mlx4_en_priv *priv = netdev_priv(dev);
203         int index = 0;
204         int i;
205
206         spin_lock_bh(&priv->stats_lock);
207
208         for (i = 0; i < NUM_MAIN_STATS; i++)
209                 data[index++] = ((unsigned long *) &priv->stats)[i];
210         for (i = 0; i < NUM_PORT_STATS; i++)
211                 data[index++] = ((unsigned long *) &priv->port_stats)[i];
212         for (i = 0; i < priv->tx_ring_num; i++) {
213                 data[index++] = priv->tx_ring[i].packets;
214                 data[index++] = priv->tx_ring[i].bytes;
215         }
216         for (i = 0; i < priv->rx_ring_num; i++) {
217                 data[index++] = priv->rx_ring[i].packets;
218                 data[index++] = priv->rx_ring[i].bytes;
219         }
220         for (i = 0; i < NUM_PKT_STATS; i++)
221                 data[index++] = ((unsigned long *) &priv->pkstats)[i];
222         spin_unlock_bh(&priv->stats_lock);
223
224 }
225
226 static void mlx4_en_self_test(struct net_device *dev,
227                               struct ethtool_test *etest, u64 *buf)
228 {
229         mlx4_en_ex_selftest(dev, &etest->flags, buf);
230 }
231
232 static void mlx4_en_get_strings(struct net_device *dev,
233                                 uint32_t stringset, uint8_t *data)
234 {
235         struct mlx4_en_priv *priv = netdev_priv(dev);
236         int index = 0;
237         int i;
238
239         switch (stringset) {
240         case ETH_SS_TEST:
241                 for (i = 0; i < MLX4_EN_NUM_SELF_TEST - 2; i++)
242                         strcpy(data + i * ETH_GSTRING_LEN, mlx4_en_test_names[i]);
243                 if (priv->mdev->dev->caps.flags & MLX4_DEV_CAP_FLAG_UC_LOOPBACK)
244                         for (; i < MLX4_EN_NUM_SELF_TEST; i++)
245                                 strcpy(data + i * ETH_GSTRING_LEN, mlx4_en_test_names[i]);
246                 break;
247
248         case ETH_SS_STATS:
249                 /* Add main counters */
250                 for (i = 0; i < NUM_MAIN_STATS; i++)
251                         strcpy(data + (index++) * ETH_GSTRING_LEN, main_strings[i]);
252                 for (i = 0; i< NUM_PORT_STATS; i++)
253                         strcpy(data + (index++) * ETH_GSTRING_LEN,
254                         main_strings[i + NUM_MAIN_STATS]);
255                 for (i = 0; i < priv->tx_ring_num; i++) {
256                         sprintf(data + (index++) * ETH_GSTRING_LEN,
257                                 "tx%d_packets", i);
258                         sprintf(data + (index++) * ETH_GSTRING_LEN,
259                                 "tx%d_bytes", i);
260                 }
261                 for (i = 0; i < priv->rx_ring_num; i++) {
262                         sprintf(data + (index++) * ETH_GSTRING_LEN,
263                                 "rx%d_packets", i);
264                         sprintf(data + (index++) * ETH_GSTRING_LEN,
265                                 "rx%d_bytes", i);
266                 }
267                 for (i = 0; i< NUM_PKT_STATS; i++)
268                         strcpy(data + (index++) * ETH_GSTRING_LEN,
269                         main_strings[i + NUM_MAIN_STATS + NUM_PORT_STATS]);
270                 break;
271         }
272 }
273
274 static int mlx4_en_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
275 {
276         struct mlx4_en_priv *priv = netdev_priv(dev);
277         int trans_type;
278
279         cmd->autoneg = AUTONEG_DISABLE;
280         cmd->supported = SUPPORTED_10000baseT_Full;
281         cmd->advertising = ADVERTISED_10000baseT_Full;
282
283         if (mlx4_en_QUERY_PORT(priv->mdev, priv->port))
284                 return -ENOMEM;
285
286         trans_type = priv->port_state.transciver;
287         if (netif_carrier_ok(dev)) {
288                 ethtool_cmd_speed_set(cmd, priv->port_state.link_speed);
289                 cmd->duplex = DUPLEX_FULL;
290         } else {
291                 ethtool_cmd_speed_set(cmd, -1);
292                 cmd->duplex = -1;
293         }
294
295         if (trans_type > 0 && trans_type <= 0xC) {
296                 cmd->port = PORT_FIBRE;
297                 cmd->transceiver = XCVR_EXTERNAL;
298                 cmd->supported |= SUPPORTED_FIBRE;
299                 cmd->advertising |= ADVERTISED_FIBRE;
300         } else if (trans_type == 0x80 || trans_type == 0) {
301                 cmd->port = PORT_TP;
302                 cmd->transceiver = XCVR_INTERNAL;
303                 cmd->supported |= SUPPORTED_TP;
304                 cmd->advertising |= ADVERTISED_TP;
305         } else  {
306                 cmd->port = -1;
307                 cmd->transceiver = -1;
308         }
309         return 0;
310 }
311
312 static int mlx4_en_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
313 {
314         if ((cmd->autoneg == AUTONEG_ENABLE) ||
315             (ethtool_cmd_speed(cmd) != SPEED_10000) ||
316             (cmd->duplex != DUPLEX_FULL))
317                 return -EINVAL;
318
319         /* Nothing to change */
320         return 0;
321 }
322
323 static int mlx4_en_get_coalesce(struct net_device *dev,
324                               struct ethtool_coalesce *coal)
325 {
326         struct mlx4_en_priv *priv = netdev_priv(dev);
327
328         coal->tx_coalesce_usecs = 0;
329         coal->tx_max_coalesced_frames = 0;
330         coal->rx_coalesce_usecs = priv->rx_usecs;
331         coal->rx_max_coalesced_frames = priv->rx_frames;
332
333         coal->pkt_rate_low = priv->pkt_rate_low;
334         coal->rx_coalesce_usecs_low = priv->rx_usecs_low;
335         coal->pkt_rate_high = priv->pkt_rate_high;
336         coal->rx_coalesce_usecs_high = priv->rx_usecs_high;
337         coal->rate_sample_interval = priv->sample_interval;
338         coal->use_adaptive_rx_coalesce = priv->adaptive_rx_coal;
339         return 0;
340 }
341
342 static int mlx4_en_set_coalesce(struct net_device *dev,
343                               struct ethtool_coalesce *coal)
344 {
345         struct mlx4_en_priv *priv = netdev_priv(dev);
346         int err, i;
347
348         priv->rx_frames = (coal->rx_max_coalesced_frames ==
349                            MLX4_EN_AUTO_CONF) ?
350                                 MLX4_EN_RX_COAL_TARGET :
351                                 coal->rx_max_coalesced_frames;
352         priv->rx_usecs = (coal->rx_coalesce_usecs ==
353                           MLX4_EN_AUTO_CONF) ?
354                                 MLX4_EN_RX_COAL_TIME :
355                                 coal->rx_coalesce_usecs;
356
357         /* Set adaptive coalescing params */
358         priv->pkt_rate_low = coal->pkt_rate_low;
359         priv->rx_usecs_low = coal->rx_coalesce_usecs_low;
360         priv->pkt_rate_high = coal->pkt_rate_high;
361         priv->rx_usecs_high = coal->rx_coalesce_usecs_high;
362         priv->sample_interval = coal->rate_sample_interval;
363         priv->adaptive_rx_coal = coal->use_adaptive_rx_coalesce;
364         if (priv->adaptive_rx_coal)
365                 return 0;
366
367         for (i = 0; i < priv->rx_ring_num; i++) {
368                 priv->rx_cq[i].moder_cnt = priv->rx_frames;
369                 priv->rx_cq[i].moder_time = priv->rx_usecs;
370                 priv->last_moder_time[i] = MLX4_EN_AUTO_CONF;
371                 err = mlx4_en_set_cq_moder(priv, &priv->rx_cq[i]);
372                 if (err)
373                         return err;
374         }
375         return 0;
376 }
377
378 static int mlx4_en_set_pauseparam(struct net_device *dev,
379                                 struct ethtool_pauseparam *pause)
380 {
381         struct mlx4_en_priv *priv = netdev_priv(dev);
382         struct mlx4_en_dev *mdev = priv->mdev;
383         int err;
384
385         priv->prof->tx_pause = pause->tx_pause != 0;
386         priv->prof->rx_pause = pause->rx_pause != 0;
387         err = mlx4_SET_PORT_general(mdev->dev, priv->port,
388                                     priv->rx_skb_size + ETH_FCS_LEN,
389                                     priv->prof->tx_pause,
390                                     priv->prof->tx_ppp,
391                                     priv->prof->rx_pause,
392                                     priv->prof->rx_ppp);
393         if (err)
394                 en_err(priv, "Failed setting pause params\n");
395
396         return err;
397 }
398
399 static void mlx4_en_get_pauseparam(struct net_device *dev,
400                                  struct ethtool_pauseparam *pause)
401 {
402         struct mlx4_en_priv *priv = netdev_priv(dev);
403
404         pause->tx_pause = priv->prof->tx_pause;
405         pause->rx_pause = priv->prof->rx_pause;
406 }
407
408 static int mlx4_en_set_ringparam(struct net_device *dev,
409                                  struct ethtool_ringparam *param)
410 {
411         struct mlx4_en_priv *priv = netdev_priv(dev);
412         struct mlx4_en_dev *mdev = priv->mdev;
413         u32 rx_size, tx_size;
414         int port_up = 0;
415         int err = 0;
416         int i;
417
418         if (param->rx_jumbo_pending || param->rx_mini_pending)
419                 return -EINVAL;
420
421         rx_size = roundup_pow_of_two(param->rx_pending);
422         rx_size = max_t(u32, rx_size, MLX4_EN_MIN_RX_SIZE);
423         rx_size = min_t(u32, rx_size, MLX4_EN_MAX_RX_SIZE);
424         tx_size = roundup_pow_of_two(param->tx_pending);
425         tx_size = max_t(u32, tx_size, MLX4_EN_MIN_TX_SIZE);
426         tx_size = min_t(u32, tx_size, MLX4_EN_MAX_TX_SIZE);
427
428         if (rx_size == (priv->port_up ? priv->rx_ring[0].actual_size :
429                                         priv->rx_ring[0].size) &&
430             tx_size == priv->tx_ring[0].size)
431                 return 0;
432
433         mutex_lock(&mdev->state_lock);
434         if (priv->port_up) {
435                 port_up = 1;
436                 mlx4_en_stop_port(dev);
437         }
438
439         mlx4_en_free_resources(priv);
440
441         priv->prof->tx_ring_size = tx_size;
442         priv->prof->rx_ring_size = rx_size;
443
444         err = mlx4_en_alloc_resources(priv);
445         if (err) {
446                 en_err(priv, "Failed reallocating port resources\n");
447                 goto out;
448         }
449         if (port_up) {
450                 err = mlx4_en_start_port(dev);
451                 if (err)
452                         en_err(priv, "Failed starting port\n");
453         }
454
455         for (i = 0; i < priv->rx_ring_num; i++) {
456                 priv->rx_cq[i].moder_cnt = priv->rx_frames;
457                 priv->rx_cq[i].moder_time = priv->rx_usecs;
458                 priv->last_moder_time[i] = MLX4_EN_AUTO_CONF;
459                 err = mlx4_en_set_cq_moder(priv, &priv->rx_cq[i]);
460                 if (err)
461                         goto out;
462         }
463
464 out:
465         mutex_unlock(&mdev->state_lock);
466         return err;
467 }
468
469 static void mlx4_en_get_ringparam(struct net_device *dev,
470                                   struct ethtool_ringparam *param)
471 {
472         struct mlx4_en_priv *priv = netdev_priv(dev);
473
474         memset(param, 0, sizeof(*param));
475         param->rx_max_pending = MLX4_EN_MAX_RX_SIZE;
476         param->tx_max_pending = MLX4_EN_MAX_TX_SIZE;
477         param->rx_pending = priv->port_up ?
478                 priv->rx_ring[0].actual_size : priv->rx_ring[0].size;
479         param->tx_pending = priv->tx_ring[0].size;
480 }
481
482 static u32 mlx4_en_get_rxfh_indir_size(struct net_device *dev)
483 {
484         struct mlx4_en_priv *priv = netdev_priv(dev);
485
486         return priv->rx_ring_num;
487 }
488
489 static int mlx4_en_get_rxfh_indir(struct net_device *dev, u32 *ring_index)
490 {
491         struct mlx4_en_priv *priv = netdev_priv(dev);
492         struct mlx4_en_rss_map *rss_map = &priv->rss_map;
493         int rss_rings;
494         size_t n = priv->rx_ring_num;
495         int err = 0;
496
497         rss_rings = priv->prof->rss_rings ?: priv->rx_ring_num;
498
499         while (n--) {
500                 ring_index[n] = rss_map->qps[n % rss_rings].qpn -
501                         rss_map->base_qpn;
502         }
503
504         return err;
505 }
506
507 static int mlx4_en_set_rxfh_indir(struct net_device *dev,
508                 const u32 *ring_index)
509 {
510         struct mlx4_en_priv *priv = netdev_priv(dev);
511         struct mlx4_en_dev *mdev = priv->mdev;
512         int port_up = 0;
513         int err = 0;
514         int i;
515         int rss_rings = 0;
516
517         /* Calculate RSS table size and make sure flows are spread evenly
518          * between rings
519          */
520         for (i = 0; i < priv->rx_ring_num; i++) {
521                 if (i > 0 && !ring_index[i] && !rss_rings)
522                         rss_rings = i;
523
524                 if (ring_index[i] != (i % (rss_rings ?: priv->rx_ring_num)))
525                         return -EINVAL;
526         }
527
528         if (!rss_rings)
529                 rss_rings = priv->rx_ring_num;
530
531         /* RSS table size must be an order of 2 */
532         if (!is_power_of_2(rss_rings))
533                 return -EINVAL;
534
535         mutex_lock(&mdev->state_lock);
536         if (priv->port_up) {
537                 port_up = 1;
538                 mlx4_en_stop_port(dev);
539         }
540
541         priv->prof->rss_rings = rss_rings;
542
543         if (port_up) {
544                 err = mlx4_en_start_port(dev);
545                 if (err)
546                         en_err(priv, "Failed starting port\n");
547         }
548
549         mutex_unlock(&mdev->state_lock);
550         return err;
551 }
552
553 static int mlx4_en_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
554                              u32 *rule_locs)
555 {
556         struct mlx4_en_priv *priv = netdev_priv(dev);
557         int err = 0;
558
559         switch (cmd->cmd) {
560         case ETHTOOL_GRXRINGS:
561                 cmd->data = priv->rx_ring_num;
562                 break;
563         default:
564                 err = -EOPNOTSUPP;
565                 break;
566         }
567
568         return err;
569 }
570
571 const struct ethtool_ops mlx4_en_ethtool_ops = {
572         .get_drvinfo = mlx4_en_get_drvinfo,
573         .get_settings = mlx4_en_get_settings,
574         .set_settings = mlx4_en_set_settings,
575         .get_link = ethtool_op_get_link,
576         .get_strings = mlx4_en_get_strings,
577         .get_sset_count = mlx4_en_get_sset_count,
578         .get_ethtool_stats = mlx4_en_get_ethtool_stats,
579         .self_test = mlx4_en_self_test,
580         .get_wol = mlx4_en_get_wol,
581         .set_wol = mlx4_en_set_wol,
582         .get_msglevel = mlx4_en_get_msglevel,
583         .set_msglevel = mlx4_en_set_msglevel,
584         .get_coalesce = mlx4_en_get_coalesce,
585         .set_coalesce = mlx4_en_set_coalesce,
586         .get_pauseparam = mlx4_en_get_pauseparam,
587         .set_pauseparam = mlx4_en_set_pauseparam,
588         .get_ringparam = mlx4_en_get_ringparam,
589         .set_ringparam = mlx4_en_set_ringparam,
590         .get_rxnfc = mlx4_en_get_rxnfc,
591         .get_rxfh_indir_size = mlx4_en_get_rxfh_indir_size,
592         .get_rxfh_indir = mlx4_en_get_rxfh_indir,
593         .set_rxfh_indir = mlx4_en_set_rxfh_indir,
594 };
595
596
597
598
599