2 * Copyright (c) 2007 Mellanox Technologies. All rights reserved.
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:
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
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.
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
34 #include <linux/kernel.h>
35 #include <linux/ethtool.h>
36 #include <linux/netdevice.h>
37 #include <linux/mlx4/driver.h>
38 #include <linux/mlx4/device.h>
41 #include <linux/bitmap.h>
46 #define EN_ETHTOOL_QP_ATTACH (1ull << 63)
47 #define EN_ETHTOOL_SHORT_MASK cpu_to_be16(0xffff)
48 #define EN_ETHTOOL_WORD_MASK cpu_to_be32(0xffffffff)
50 static int mlx4_en_moderation_update(struct mlx4_en_priv
*priv
)
55 for (t
= 0 ; t
< MLX4_EN_NUM_TX_TYPES
; t
++) {
56 for (i
= 0; i
< priv
->tx_ring_num
[t
]; i
++) {
57 priv
->tx_cq
[t
][i
]->moder_cnt
= priv
->tx_frames
;
58 priv
->tx_cq
[t
][i
]->moder_time
= priv
->tx_usecs
;
60 err
= mlx4_en_set_cq_moder(priv
,
68 if (priv
->adaptive_rx_coal
)
71 for (i
= 0; i
< priv
->rx_ring_num
; i
++) {
72 priv
->rx_cq
[i
]->moder_cnt
= priv
->rx_frames
;
73 priv
->rx_cq
[i
]->moder_time
= priv
->rx_usecs
;
74 priv
->last_moder_time
[i
] = MLX4_EN_AUTO_CONF
;
76 err
= mlx4_en_set_cq_moder(priv
, priv
->rx_cq
[i
]);
86 mlx4_en_get_drvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*drvinfo
)
88 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
89 struct mlx4_en_dev
*mdev
= priv
->mdev
;
91 strlcpy(drvinfo
->driver
, DRV_NAME
, sizeof(drvinfo
->driver
));
92 strlcpy(drvinfo
->version
, DRV_VERSION
,
93 sizeof(drvinfo
->version
));
94 snprintf(drvinfo
->fw_version
, sizeof(drvinfo
->fw_version
),
96 (u16
) (mdev
->dev
->caps
.fw_ver
>> 32),
97 (u16
) ((mdev
->dev
->caps
.fw_ver
>> 16) & 0xffff),
98 (u16
) (mdev
->dev
->caps
.fw_ver
& 0xffff));
99 strlcpy(drvinfo
->bus_info
, pci_name(mdev
->dev
->persist
->pdev
),
100 sizeof(drvinfo
->bus_info
));
103 static const char mlx4_en_priv_flags
[][ETH_GSTRING_LEN
] = {
108 static const char main_strings
[][ETH_GSTRING_LEN
] = {
109 /* main statistics */
110 "rx_packets", "tx_packets", "rx_bytes", "tx_bytes", "rx_errors",
111 "tx_errors", "rx_dropped", "tx_dropped", "multicast", "collisions",
112 "rx_length_errors", "rx_over_errors", "rx_crc_errors",
113 "rx_frame_errors", "rx_fifo_errors", "rx_missed_errors",
114 "tx_aborted_errors", "tx_carrier_errors", "tx_fifo_errors",
115 "tx_heartbeat_errors", "tx_window_errors",
117 /* port statistics */
120 "queue_stopped", "wake_queue", "tx_timeout", "rx_alloc_pages",
121 "rx_csum_good", "rx_csum_none", "rx_csum_complete", "tx_chksum_offload",
129 /* priority flow control statistics rx */
130 "rx_pause_prio_0", "rx_pause_duration_prio_0",
131 "rx_pause_transition_prio_0",
132 "rx_pause_prio_1", "rx_pause_duration_prio_1",
133 "rx_pause_transition_prio_1",
134 "rx_pause_prio_2", "rx_pause_duration_prio_2",
135 "rx_pause_transition_prio_2",
136 "rx_pause_prio_3", "rx_pause_duration_prio_3",
137 "rx_pause_transition_prio_3",
138 "rx_pause_prio_4", "rx_pause_duration_prio_4",
139 "rx_pause_transition_prio_4",
140 "rx_pause_prio_5", "rx_pause_duration_prio_5",
141 "rx_pause_transition_prio_5",
142 "rx_pause_prio_6", "rx_pause_duration_prio_6",
143 "rx_pause_transition_prio_6",
144 "rx_pause_prio_7", "rx_pause_duration_prio_7",
145 "rx_pause_transition_prio_7",
147 /* flow control statistics rx */
148 "rx_pause", "rx_pause_duration", "rx_pause_transition",
150 /* priority flow control statistics tx */
151 "tx_pause_prio_0", "tx_pause_duration_prio_0",
152 "tx_pause_transition_prio_0",
153 "tx_pause_prio_1", "tx_pause_duration_prio_1",
154 "tx_pause_transition_prio_1",
155 "tx_pause_prio_2", "tx_pause_duration_prio_2",
156 "tx_pause_transition_prio_2",
157 "tx_pause_prio_3", "tx_pause_duration_prio_3",
158 "tx_pause_transition_prio_3",
159 "tx_pause_prio_4", "tx_pause_duration_prio_4",
160 "tx_pause_transition_prio_4",
161 "tx_pause_prio_5", "tx_pause_duration_prio_5",
162 "tx_pause_transition_prio_5",
163 "tx_pause_prio_6", "tx_pause_duration_prio_6",
164 "tx_pause_transition_prio_6",
165 "tx_pause_prio_7", "tx_pause_duration_prio_7",
166 "tx_pause_transition_prio_7",
168 /* flow control statistics tx */
169 "tx_pause", "tx_pause_duration", "tx_pause_transition",
171 /* packet statistics */
172 "rx_multicast_packets",
173 "rx_broadcast_packets",
175 "rx_in_range_length_error",
176 "rx_out_range_length_error",
177 "tx_multicast_packets",
178 "tx_broadcast_packets",
179 "rx_prio_0_packets", "rx_prio_0_bytes",
180 "rx_prio_1_packets", "rx_prio_1_bytes",
181 "rx_prio_2_packets", "rx_prio_2_bytes",
182 "rx_prio_3_packets", "rx_prio_3_bytes",
183 "rx_prio_4_packets", "rx_prio_4_bytes",
184 "rx_prio_5_packets", "rx_prio_5_bytes",
185 "rx_prio_6_packets", "rx_prio_6_bytes",
186 "rx_prio_7_packets", "rx_prio_7_bytes",
187 "rx_novlan_packets", "rx_novlan_bytes",
188 "tx_prio_0_packets", "tx_prio_0_bytes",
189 "tx_prio_1_packets", "tx_prio_1_bytes",
190 "tx_prio_2_packets", "tx_prio_2_bytes",
191 "tx_prio_3_packets", "tx_prio_3_bytes",
192 "tx_prio_4_packets", "tx_prio_4_bytes",
193 "tx_prio_5_packets", "tx_prio_5_bytes",
194 "tx_prio_6_packets", "tx_prio_6_bytes",
195 "tx_prio_7_packets", "tx_prio_7_bytes",
196 "tx_novlan_packets", "tx_novlan_bytes",
204 static const char mlx4_en_test_names
[][ETH_GSTRING_LEN
]= {
212 static u32
mlx4_en_get_msglevel(struct net_device
*dev
)
214 return ((struct mlx4_en_priv
*) netdev_priv(dev
))->msg_enable
;
217 static void mlx4_en_set_msglevel(struct net_device
*dev
, u32 val
)
219 ((struct mlx4_en_priv
*) netdev_priv(dev
))->msg_enable
= val
;
222 static void mlx4_en_get_wol(struct net_device
*netdev
,
223 struct ethtool_wolinfo
*wol
)
225 struct mlx4_en_priv
*priv
= netdev_priv(netdev
);
230 if ((priv
->port
< 1) || (priv
->port
> 2)) {
231 en_err(priv
, "Failed to get WoL information\n");
235 mask
= (priv
->port
== 1) ? MLX4_DEV_CAP_FLAG_WOL_PORT1
:
236 MLX4_DEV_CAP_FLAG_WOL_PORT2
;
238 if (!(priv
->mdev
->dev
->caps
.flags
& mask
)) {
244 err
= mlx4_wol_read(priv
->mdev
->dev
, &config
, priv
->port
);
246 en_err(priv
, "Failed to get WoL information\n");
250 if (config
& MLX4_EN_WOL_MAGIC
)
251 wol
->supported
= WAKE_MAGIC
;
255 if (config
& MLX4_EN_WOL_ENABLED
)
256 wol
->wolopts
= WAKE_MAGIC
;
261 static int mlx4_en_set_wol(struct net_device
*netdev
,
262 struct ethtool_wolinfo
*wol
)
264 struct mlx4_en_priv
*priv
= netdev_priv(netdev
);
269 if ((priv
->port
< 1) || (priv
->port
> 2))
272 mask
= (priv
->port
== 1) ? MLX4_DEV_CAP_FLAG_WOL_PORT1
:
273 MLX4_DEV_CAP_FLAG_WOL_PORT2
;
275 if (!(priv
->mdev
->dev
->caps
.flags
& mask
))
278 if (wol
->supported
& ~WAKE_MAGIC
)
281 err
= mlx4_wol_read(priv
->mdev
->dev
, &config
, priv
->port
);
283 en_err(priv
, "Failed to get WoL info, unable to modify\n");
287 if (wol
->wolopts
& WAKE_MAGIC
) {
288 config
|= MLX4_EN_WOL_DO_MODIFY
| MLX4_EN_WOL_ENABLED
|
291 config
&= ~(MLX4_EN_WOL_ENABLED
| MLX4_EN_WOL_MAGIC
);
292 config
|= MLX4_EN_WOL_DO_MODIFY
;
295 err
= mlx4_wol_write(priv
->mdev
->dev
, config
, priv
->port
);
297 en_err(priv
, "Failed to set WoL information\n");
302 struct bitmap_iterator
{
303 unsigned long *stats_bitmap
;
305 unsigned int iterator
;
306 bool advance_array
; /* if set, force no increments */
309 static inline void bitmap_iterator_init(struct bitmap_iterator
*h
,
310 unsigned long *stats_bitmap
,
314 h
->advance_array
= !bitmap_empty(stats_bitmap
, count
);
315 h
->count
= h
->advance_array
? bitmap_weight(stats_bitmap
, count
)
317 h
->stats_bitmap
= stats_bitmap
;
320 static inline int bitmap_iterator_test(struct bitmap_iterator
*h
)
322 return !h
->advance_array
? 1 : test_bit(h
->iterator
, h
->stats_bitmap
);
325 static inline int bitmap_iterator_inc(struct bitmap_iterator
*h
)
327 return h
->iterator
++;
330 static inline unsigned int
331 bitmap_iterator_count(struct bitmap_iterator
*h
)
336 static int mlx4_en_get_sset_count(struct net_device
*dev
, int sset
)
338 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
339 struct bitmap_iterator it
;
341 bitmap_iterator_init(&it
, priv
->stats_bitmap
.bitmap
, NUM_ALL_STATS
);
345 return bitmap_iterator_count(&it
) +
346 (priv
->tx_ring_num
[TX
] * 2) +
347 (priv
->rx_ring_num
* (3 + NUM_XDP_STATS
));
349 return MLX4_EN_NUM_SELF_TEST
- !(priv
->mdev
->dev
->caps
.flags
350 & MLX4_DEV_CAP_FLAG_UC_LOOPBACK
) * 2;
351 case ETH_SS_PRIV_FLAGS
:
352 return ARRAY_SIZE(mlx4_en_priv_flags
);
358 static void mlx4_en_get_ethtool_stats(struct net_device
*dev
,
359 struct ethtool_stats
*stats
, uint64_t *data
)
361 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
364 struct bitmap_iterator it
;
366 bitmap_iterator_init(&it
, priv
->stats_bitmap
.bitmap
, NUM_ALL_STATS
);
368 spin_lock_bh(&priv
->stats_lock
);
370 mlx4_en_fold_software_stats(dev
);
372 for (i
= 0; i
< NUM_MAIN_STATS
; i
++, bitmap_iterator_inc(&it
))
373 if (bitmap_iterator_test(&it
))
374 data
[index
++] = ((unsigned long *)&dev
->stats
)[i
];
376 for (i
= 0; i
< NUM_PORT_STATS
; i
++, bitmap_iterator_inc(&it
))
377 if (bitmap_iterator_test(&it
))
378 data
[index
++] = ((unsigned long *)&priv
->port_stats
)[i
];
380 for (i
= 0; i
< NUM_PF_STATS
; i
++, bitmap_iterator_inc(&it
))
381 if (bitmap_iterator_test(&it
))
383 ((unsigned long *)&priv
->pf_stats
)[i
];
385 for (i
= 0; i
< NUM_FLOW_PRIORITY_STATS_RX
;
386 i
++, bitmap_iterator_inc(&it
))
387 if (bitmap_iterator_test(&it
))
389 ((u64
*)&priv
->rx_priority_flowstats
)[i
];
391 for (i
= 0; i
< NUM_FLOW_STATS_RX
; i
++, bitmap_iterator_inc(&it
))
392 if (bitmap_iterator_test(&it
))
393 data
[index
++] = ((u64
*)&priv
->rx_flowstats
)[i
];
395 for (i
= 0; i
< NUM_FLOW_PRIORITY_STATS_TX
;
396 i
++, bitmap_iterator_inc(&it
))
397 if (bitmap_iterator_test(&it
))
399 ((u64
*)&priv
->tx_priority_flowstats
)[i
];
401 for (i
= 0; i
< NUM_FLOW_STATS_TX
; i
++, bitmap_iterator_inc(&it
))
402 if (bitmap_iterator_test(&it
))
403 data
[index
++] = ((u64
*)&priv
->tx_flowstats
)[i
];
405 for (i
= 0; i
< NUM_PKT_STATS
; i
++, bitmap_iterator_inc(&it
))
406 if (bitmap_iterator_test(&it
))
407 data
[index
++] = ((unsigned long *)&priv
->pkstats
)[i
];
409 for (i
= 0; i
< NUM_XDP_STATS
; i
++, bitmap_iterator_inc(&it
))
410 if (bitmap_iterator_test(&it
))
411 data
[index
++] = ((unsigned long *)&priv
->xdp_stats
)[i
];
413 for (i
= 0; i
< priv
->tx_ring_num
[TX
]; i
++) {
414 data
[index
++] = priv
->tx_ring
[TX
][i
]->packets
;
415 data
[index
++] = priv
->tx_ring
[TX
][i
]->bytes
;
417 for (i
= 0; i
< priv
->rx_ring_num
; i
++) {
418 data
[index
++] = priv
->rx_ring
[i
]->packets
;
419 data
[index
++] = priv
->rx_ring
[i
]->bytes
;
420 data
[index
++] = priv
->rx_ring
[i
]->dropped
;
421 data
[index
++] = priv
->rx_ring
[i
]->xdp_drop
;
422 data
[index
++] = priv
->rx_ring
[i
]->xdp_tx
;
423 data
[index
++] = priv
->rx_ring
[i
]->xdp_tx_full
;
425 spin_unlock_bh(&priv
->stats_lock
);
429 static void mlx4_en_self_test(struct net_device
*dev
,
430 struct ethtool_test
*etest
, u64
*buf
)
432 mlx4_en_ex_selftest(dev
, &etest
->flags
, buf
);
435 static void mlx4_en_get_strings(struct net_device
*dev
,
436 uint32_t stringset
, uint8_t *data
)
438 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
441 struct bitmap_iterator it
;
443 bitmap_iterator_init(&it
, priv
->stats_bitmap
.bitmap
, NUM_ALL_STATS
);
447 for (i
= 0; i
< MLX4_EN_NUM_SELF_TEST
- 2; i
++)
448 strcpy(data
+ i
* ETH_GSTRING_LEN
, mlx4_en_test_names
[i
]);
449 if (priv
->mdev
->dev
->caps
.flags
& MLX4_DEV_CAP_FLAG_UC_LOOPBACK
)
450 for (; i
< MLX4_EN_NUM_SELF_TEST
; i
++)
451 strcpy(data
+ i
* ETH_GSTRING_LEN
, mlx4_en_test_names
[i
]);
455 /* Add main counters */
456 for (i
= 0; i
< NUM_MAIN_STATS
; i
++, strings
++,
457 bitmap_iterator_inc(&it
))
458 if (bitmap_iterator_test(&it
))
459 strcpy(data
+ (index
++) * ETH_GSTRING_LEN
,
460 main_strings
[strings
]);
462 for (i
= 0; i
< NUM_PORT_STATS
; i
++, strings
++,
463 bitmap_iterator_inc(&it
))
464 if (bitmap_iterator_test(&it
))
465 strcpy(data
+ (index
++) * ETH_GSTRING_LEN
,
466 main_strings
[strings
]);
468 for (i
= 0; i
< NUM_PF_STATS
; i
++, strings
++,
469 bitmap_iterator_inc(&it
))
470 if (bitmap_iterator_test(&it
))
471 strcpy(data
+ (index
++) * ETH_GSTRING_LEN
,
472 main_strings
[strings
]);
474 for (i
= 0; i
< NUM_FLOW_STATS
; i
++, strings
++,
475 bitmap_iterator_inc(&it
))
476 if (bitmap_iterator_test(&it
))
477 strcpy(data
+ (index
++) * ETH_GSTRING_LEN
,
478 main_strings
[strings
]);
480 for (i
= 0; i
< NUM_PKT_STATS
; i
++, strings
++,
481 bitmap_iterator_inc(&it
))
482 if (bitmap_iterator_test(&it
))
483 strcpy(data
+ (index
++) * ETH_GSTRING_LEN
,
484 main_strings
[strings
]);
486 for (i
= 0; i
< NUM_XDP_STATS
; i
++, strings
++,
487 bitmap_iterator_inc(&it
))
488 if (bitmap_iterator_test(&it
))
489 strcpy(data
+ (index
++) * ETH_GSTRING_LEN
,
490 main_strings
[strings
]);
492 for (i
= 0; i
< priv
->tx_ring_num
[TX
]; i
++) {
493 sprintf(data
+ (index
++) * ETH_GSTRING_LEN
,
495 sprintf(data
+ (index
++) * ETH_GSTRING_LEN
,
498 for (i
= 0; i
< priv
->rx_ring_num
; i
++) {
499 sprintf(data
+ (index
++) * ETH_GSTRING_LEN
,
501 sprintf(data
+ (index
++) * ETH_GSTRING_LEN
,
503 sprintf(data
+ (index
++) * ETH_GSTRING_LEN
,
505 sprintf(data
+ (index
++) * ETH_GSTRING_LEN
,
507 sprintf(data
+ (index
++) * ETH_GSTRING_LEN
,
509 sprintf(data
+ (index
++) * ETH_GSTRING_LEN
,
510 "rx%d_xdp_tx_full", i
);
513 case ETH_SS_PRIV_FLAGS
:
514 for (i
= 0; i
< ARRAY_SIZE(mlx4_en_priv_flags
); i
++)
515 strcpy(data
+ i
* ETH_GSTRING_LEN
,
516 mlx4_en_priv_flags
[i
]);
522 static u32
mlx4_en_autoneg_get(struct net_device
*dev
)
524 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
525 struct mlx4_en_dev
*mdev
= priv
->mdev
;
526 u32 autoneg
= AUTONEG_DISABLE
;
528 if ((mdev
->dev
->caps
.flags2
& MLX4_DEV_CAP_FLAG2_ETH_BACKPL_AN_REP
) &&
529 (priv
->port_state
.flags
& MLX4_EN_PORT_ANE
))
530 autoneg
= AUTONEG_ENABLE
;
535 static void ptys2ethtool_update_supported_port(unsigned long *mask
,
536 struct mlx4_ptys_reg
*ptys_reg
)
538 u32 eth_proto
= be32_to_cpu(ptys_reg
->eth_proto_cap
);
540 if (eth_proto
& (MLX4_PROT_MASK(MLX4_10GBASE_T
)
541 | MLX4_PROT_MASK(MLX4_1000BASE_T
)
542 | MLX4_PROT_MASK(MLX4_100BASE_TX
))) {
543 __set_bit(ETHTOOL_LINK_MODE_TP_BIT
, mask
);
544 } else if (eth_proto
& (MLX4_PROT_MASK(MLX4_10GBASE_CR
)
545 | MLX4_PROT_MASK(MLX4_10GBASE_SR
)
546 | MLX4_PROT_MASK(MLX4_56GBASE_SR4
)
547 | MLX4_PROT_MASK(MLX4_40GBASE_CR4
)
548 | MLX4_PROT_MASK(MLX4_40GBASE_SR4
)
549 | MLX4_PROT_MASK(MLX4_1000BASE_CX_SGMII
))) {
550 __set_bit(ETHTOOL_LINK_MODE_FIBRE_BIT
, mask
);
551 } else if (eth_proto
& (MLX4_PROT_MASK(MLX4_56GBASE_KR4
)
552 | MLX4_PROT_MASK(MLX4_40GBASE_KR4
)
553 | MLX4_PROT_MASK(MLX4_20GBASE_KR2
)
554 | MLX4_PROT_MASK(MLX4_10GBASE_KR
)
555 | MLX4_PROT_MASK(MLX4_10GBASE_KX4
)
556 | MLX4_PROT_MASK(MLX4_1000BASE_KX
))) {
557 __set_bit(ETHTOOL_LINK_MODE_Backplane_BIT
, mask
);
561 static u32
ptys_get_active_port(struct mlx4_ptys_reg
*ptys_reg
)
563 u32 eth_proto
= be32_to_cpu(ptys_reg
->eth_proto_oper
);
565 if (!eth_proto
) /* link down */
566 eth_proto
= be32_to_cpu(ptys_reg
->eth_proto_cap
);
568 if (eth_proto
& (MLX4_PROT_MASK(MLX4_10GBASE_T
)
569 | MLX4_PROT_MASK(MLX4_1000BASE_T
)
570 | MLX4_PROT_MASK(MLX4_100BASE_TX
))) {
574 if (eth_proto
& (MLX4_PROT_MASK(MLX4_10GBASE_SR
)
575 | MLX4_PROT_MASK(MLX4_56GBASE_SR4
)
576 | MLX4_PROT_MASK(MLX4_40GBASE_SR4
)
577 | MLX4_PROT_MASK(MLX4_1000BASE_CX_SGMII
))) {
581 if (eth_proto
& (MLX4_PROT_MASK(MLX4_10GBASE_CR
)
582 | MLX4_PROT_MASK(MLX4_56GBASE_CR4
)
583 | MLX4_PROT_MASK(MLX4_40GBASE_CR4
))) {
587 if (eth_proto
& (MLX4_PROT_MASK(MLX4_56GBASE_KR4
)
588 | MLX4_PROT_MASK(MLX4_40GBASE_KR4
)
589 | MLX4_PROT_MASK(MLX4_20GBASE_KR2
)
590 | MLX4_PROT_MASK(MLX4_10GBASE_KR
)
591 | MLX4_PROT_MASK(MLX4_10GBASE_KX4
)
592 | MLX4_PROT_MASK(MLX4_1000BASE_KX
))) {
598 #define MLX4_LINK_MODES_SZ \
599 (FIELD_SIZEOF(struct mlx4_ptys_reg, eth_proto_cap) * 8)
601 enum ethtool_report
{
606 struct ptys2ethtool_config
{
607 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported
);
608 __ETHTOOL_DECLARE_LINK_MODE_MASK(advertised
);
612 static unsigned long *ptys2ethtool_link_mode(struct ptys2ethtool_config
*cfg
,
613 enum ethtool_report report
)
617 return cfg
->supported
;
619 return cfg
->advertised
;
624 #define MLX4_BUILD_PTYS2ETHTOOL_CONFIG(reg_, speed_, ...) \
626 struct ptys2ethtool_config *cfg; \
627 const unsigned int modes[] = { __VA_ARGS__ }; \
629 cfg = &ptys2ethtool_map[reg_]; \
630 cfg->speed = speed_; \
631 bitmap_zero(cfg->supported, \
632 __ETHTOOL_LINK_MODE_MASK_NBITS); \
633 bitmap_zero(cfg->advertised, \
634 __ETHTOOL_LINK_MODE_MASK_NBITS); \
635 for (i = 0 ; i < ARRAY_SIZE(modes) ; ++i) { \
636 __set_bit(modes[i], cfg->supported); \
637 __set_bit(modes[i], cfg->advertised); \
641 /* Translates mlx4 link mode to equivalent ethtool Link modes/speed */
642 static struct ptys2ethtool_config ptys2ethtool_map
[MLX4_LINK_MODES_SZ
];
644 void __init
mlx4_en_init_ptys2ethtool_map(void)
646 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_100BASE_TX
, SPEED_100
,
647 ETHTOOL_LINK_MODE_100baseT_Full_BIT
);
648 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_1000BASE_T
, SPEED_1000
,
649 ETHTOOL_LINK_MODE_1000baseT_Full_BIT
);
650 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_1000BASE_CX_SGMII
, SPEED_1000
,
651 ETHTOOL_LINK_MODE_1000baseKX_Full_BIT
);
652 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_1000BASE_KX
, SPEED_1000
,
653 ETHTOOL_LINK_MODE_1000baseKX_Full_BIT
);
654 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_T
, SPEED_10000
,
655 ETHTOOL_LINK_MODE_10000baseT_Full_BIT
);
656 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_CX4
, SPEED_10000
,
657 ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT
);
658 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_KX4
, SPEED_10000
,
659 ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT
);
660 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_KR
, SPEED_10000
,
661 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT
);
662 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_CR
, SPEED_10000
,
663 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT
);
664 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_SR
, SPEED_10000
,
665 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT
);
666 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_20GBASE_KR2
, SPEED_20000
,
667 ETHTOOL_LINK_MODE_20000baseMLD2_Full_BIT
,
668 ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT
);
669 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_40GBASE_CR4
, SPEED_40000
,
670 ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT
);
671 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_40GBASE_KR4
, SPEED_40000
,
672 ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT
);
673 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_40GBASE_SR4
, SPEED_40000
,
674 ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT
);
675 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_56GBASE_KR4
, SPEED_56000
,
676 ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT
);
677 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_56GBASE_CR4
, SPEED_56000
,
678 ETHTOOL_LINK_MODE_56000baseCR4_Full_BIT
);
679 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_56GBASE_SR4
, SPEED_56000
,
680 ETHTOOL_LINK_MODE_56000baseSR4_Full_BIT
);
683 static void ptys2ethtool_update_link_modes(unsigned long *link_modes
,
685 enum ethtool_report report
)
688 for (i
= 0; i
< MLX4_LINK_MODES_SZ
; i
++) {
689 if (eth_proto
& MLX4_PROT_MASK(i
))
690 bitmap_or(link_modes
, link_modes
,
691 ptys2ethtool_link_mode(&ptys2ethtool_map
[i
],
693 __ETHTOOL_LINK_MODE_MASK_NBITS
);
697 static u32
ethtool2ptys_link_modes(const unsigned long *link_modes
,
698 enum ethtool_report report
)
703 for (i
= 0; i
< MLX4_LINK_MODES_SZ
; i
++) {
704 if (bitmap_intersects(
705 ptys2ethtool_link_mode(&ptys2ethtool_map
[i
],
708 __ETHTOOL_LINK_MODE_MASK_NBITS
))
709 ptys_modes
|= 1 << i
;
714 /* Convert actual speed (SPEED_XXX) to ptys link modes */
715 static u32
speed2ptys_link_modes(u32 speed
)
720 for (i
= 0; i
< MLX4_LINK_MODES_SZ
; i
++) {
721 if (ptys2ethtool_map
[i
].speed
== speed
)
722 ptys_modes
|= 1 << i
;
728 ethtool_get_ptys_link_ksettings(struct net_device
*dev
,
729 struct ethtool_link_ksettings
*link_ksettings
)
731 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
732 struct mlx4_ptys_reg ptys_reg
;
736 memset(&ptys_reg
, 0, sizeof(ptys_reg
));
737 ptys_reg
.local_port
= priv
->port
;
738 ptys_reg
.proto_mask
= MLX4_PTYS_EN
;
739 ret
= mlx4_ACCESS_PTYS_REG(priv
->mdev
->dev
,
740 MLX4_ACCESS_REG_QUERY
, &ptys_reg
);
742 en_warn(priv
, "Failed to run mlx4_ACCESS_PTYS_REG status(%x)",
746 en_dbg(DRV
, priv
, "ptys_reg.proto_mask %x\n",
747 ptys_reg
.proto_mask
);
748 en_dbg(DRV
, priv
, "ptys_reg.eth_proto_cap %x\n",
749 be32_to_cpu(ptys_reg
.eth_proto_cap
));
750 en_dbg(DRV
, priv
, "ptys_reg.eth_proto_admin %x\n",
751 be32_to_cpu(ptys_reg
.eth_proto_admin
));
752 en_dbg(DRV
, priv
, "ptys_reg.eth_proto_oper %x\n",
753 be32_to_cpu(ptys_reg
.eth_proto_oper
));
754 en_dbg(DRV
, priv
, "ptys_reg.eth_proto_lp_adv %x\n",
755 be32_to_cpu(ptys_reg
.eth_proto_lp_adv
));
757 /* reset supported/advertising masks */
758 ethtool_link_ksettings_zero_link_mode(link_ksettings
, supported
);
759 ethtool_link_ksettings_zero_link_mode(link_ksettings
, advertising
);
761 ptys2ethtool_update_supported_port(link_ksettings
->link_modes
.supported
,
764 eth_proto
= be32_to_cpu(ptys_reg
.eth_proto_cap
);
765 ptys2ethtool_update_link_modes(link_ksettings
->link_modes
.supported
,
766 eth_proto
, SUPPORTED
);
768 eth_proto
= be32_to_cpu(ptys_reg
.eth_proto_admin
);
769 ptys2ethtool_update_link_modes(link_ksettings
->link_modes
.advertising
,
770 eth_proto
, ADVERTISED
);
772 ethtool_link_ksettings_add_link_mode(link_ksettings
, supported
,
774 ethtool_link_ksettings_add_link_mode(link_ksettings
, supported
,
777 if (priv
->prof
->tx_pause
)
778 ethtool_link_ksettings_add_link_mode(link_ksettings
,
780 if (priv
->prof
->tx_pause
^ priv
->prof
->rx_pause
)
781 ethtool_link_ksettings_add_link_mode(link_ksettings
,
782 advertising
, Asym_Pause
);
784 link_ksettings
->base
.port
= ptys_get_active_port(&ptys_reg
);
786 if (mlx4_en_autoneg_get(dev
)) {
787 ethtool_link_ksettings_add_link_mode(link_ksettings
,
789 ethtool_link_ksettings_add_link_mode(link_ksettings
,
790 advertising
, Autoneg
);
793 link_ksettings
->base
.autoneg
794 = (priv
->port_state
.flags
& MLX4_EN_PORT_ANC
) ?
795 AUTONEG_ENABLE
: AUTONEG_DISABLE
;
797 eth_proto
= be32_to_cpu(ptys_reg
.eth_proto_lp_adv
);
799 ethtool_link_ksettings_zero_link_mode(link_ksettings
, lp_advertising
);
800 ptys2ethtool_update_link_modes(
801 link_ksettings
->link_modes
.lp_advertising
,
802 eth_proto
, ADVERTISED
);
803 if (priv
->port_state
.flags
& MLX4_EN_PORT_ANC
)
804 ethtool_link_ksettings_add_link_mode(link_ksettings
,
805 lp_advertising
, Autoneg
);
807 link_ksettings
->base
.phy_address
= 0;
808 link_ksettings
->base
.mdio_support
= 0;
809 link_ksettings
->base
.eth_tp_mdix
= ETH_TP_MDI_INVALID
;
810 link_ksettings
->base
.eth_tp_mdix_ctrl
= ETH_TP_MDI_AUTO
;
816 ethtool_get_default_link_ksettings(
817 struct net_device
*dev
, struct ethtool_link_ksettings
*link_ksettings
)
819 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
822 link_ksettings
->base
.autoneg
= AUTONEG_DISABLE
;
824 ethtool_link_ksettings_zero_link_mode(link_ksettings
, supported
);
825 ethtool_link_ksettings_add_link_mode(link_ksettings
, supported
,
828 ethtool_link_ksettings_zero_link_mode(link_ksettings
, advertising
);
829 ethtool_link_ksettings_add_link_mode(link_ksettings
, advertising
,
832 trans_type
= priv
->port_state
.transceiver
;
833 if (trans_type
> 0 && trans_type
<= 0xC) {
834 link_ksettings
->base
.port
= PORT_FIBRE
;
835 ethtool_link_ksettings_add_link_mode(link_ksettings
,
837 ethtool_link_ksettings_add_link_mode(link_ksettings
,
839 } else if (trans_type
== 0x80 || trans_type
== 0) {
840 link_ksettings
->base
.port
= PORT_TP
;
841 ethtool_link_ksettings_add_link_mode(link_ksettings
,
843 ethtool_link_ksettings_add_link_mode(link_ksettings
,
846 link_ksettings
->base
.port
= -1;
851 mlx4_en_get_link_ksettings(struct net_device
*dev
,
852 struct ethtool_link_ksettings
*link_ksettings
)
854 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
857 if (mlx4_en_QUERY_PORT(priv
->mdev
, priv
->port
))
860 en_dbg(DRV
, priv
, "query port state.flags ANC(%x) ANE(%x)\n",
861 priv
->port_state
.flags
& MLX4_EN_PORT_ANC
,
862 priv
->port_state
.flags
& MLX4_EN_PORT_ANE
);
864 if (priv
->mdev
->dev
->caps
.flags2
& MLX4_DEV_CAP_FLAG2_ETH_PROT_CTRL
)
865 ret
= ethtool_get_ptys_link_ksettings(dev
, link_ksettings
);
866 if (ret
) /* ETH PROT CRTL is not supported or PTYS CMD failed */
867 ethtool_get_default_link_ksettings(dev
, link_ksettings
);
869 if (netif_carrier_ok(dev
)) {
870 link_ksettings
->base
.speed
= priv
->port_state
.link_speed
;
871 link_ksettings
->base
.duplex
= DUPLEX_FULL
;
873 link_ksettings
->base
.speed
= SPEED_UNKNOWN
;
874 link_ksettings
->base
.duplex
= DUPLEX_UNKNOWN
;
879 /* Calculate PTYS admin according ethtool speed (SPEED_XXX) */
880 static __be32
speed_set_ptys_admin(struct mlx4_en_priv
*priv
, u32 speed
,
883 __be32 proto_admin
= 0;
885 if (!speed
) { /* Speed = 0 ==> Reset Link modes */
886 proto_admin
= proto_cap
;
887 en_info(priv
, "Speed was set to 0, Reset advertised Link Modes to default (%x)\n",
888 be32_to_cpu(proto_cap
));
890 u32 ptys_link_modes
= speed2ptys_link_modes(speed
);
892 proto_admin
= cpu_to_be32(ptys_link_modes
) & proto_cap
;
893 en_info(priv
, "Setting Speed to %d\n", speed
);
899 mlx4_en_set_link_ksettings(struct net_device
*dev
,
900 const struct ethtool_link_ksettings
*link_ksettings
)
902 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
903 struct mlx4_ptys_reg ptys_reg
;
908 u32 ptys_adv
= ethtool2ptys_link_modes(
909 link_ksettings
->link_modes
.advertising
, ADVERTISED
);
910 const int speed
= link_ksettings
->base
.speed
;
913 "Set Speed=%d adv={%*pbl} autoneg=%d duplex=%d\n",
914 speed
, __ETHTOOL_LINK_MODE_MASK_NBITS
,
915 link_ksettings
->link_modes
.advertising
,
916 link_ksettings
->base
.autoneg
,
917 link_ksettings
->base
.duplex
);
919 if (!(priv
->mdev
->dev
->caps
.flags2
&
920 MLX4_DEV_CAP_FLAG2_ETH_PROT_CTRL
) ||
921 (link_ksettings
->base
.duplex
== DUPLEX_HALF
))
924 memset(&ptys_reg
, 0, sizeof(ptys_reg
));
925 ptys_reg
.local_port
= priv
->port
;
926 ptys_reg
.proto_mask
= MLX4_PTYS_EN
;
927 ret
= mlx4_ACCESS_PTYS_REG(priv
->mdev
->dev
,
928 MLX4_ACCESS_REG_QUERY
, &ptys_reg
);
930 en_warn(priv
, "Failed to QUERY mlx4_ACCESS_PTYS_REG status(%x)\n",
935 cur_autoneg
= ptys_reg
.flags
& MLX4_PTYS_AN_DISABLE_ADMIN
?
936 AUTONEG_DISABLE
: AUTONEG_ENABLE
;
938 if (link_ksettings
->base
.autoneg
== AUTONEG_DISABLE
) {
939 proto_admin
= speed_set_ptys_admin(priv
, speed
,
940 ptys_reg
.eth_proto_cap
);
941 if ((be32_to_cpu(proto_admin
) &
942 (MLX4_PROT_MASK(MLX4_1000BASE_CX_SGMII
) |
943 MLX4_PROT_MASK(MLX4_1000BASE_KX
))) &&
944 (ptys_reg
.flags
& MLX4_PTYS_AN_DISABLE_CAP
))
945 ptys_reg
.flags
|= MLX4_PTYS_AN_DISABLE_ADMIN
;
947 proto_admin
= cpu_to_be32(ptys_adv
);
948 ptys_reg
.flags
&= ~MLX4_PTYS_AN_DISABLE_ADMIN
;
951 proto_admin
&= ptys_reg
.eth_proto_cap
;
953 en_warn(priv
, "Not supported link mode(s) requested, check supported link modes.\n");
954 return -EINVAL
; /* nothing to change due to bad input */
957 if ((proto_admin
== ptys_reg
.eth_proto_admin
) &&
958 ((ptys_reg
.flags
& MLX4_PTYS_AN_DISABLE_CAP
) &&
959 (link_ksettings
->base
.autoneg
== cur_autoneg
)))
960 return 0; /* Nothing to change */
962 en_dbg(DRV
, priv
, "mlx4_ACCESS_PTYS_REG SET: ptys_reg.eth_proto_admin = 0x%x\n",
963 be32_to_cpu(proto_admin
));
965 ptys_reg
.eth_proto_admin
= proto_admin
;
966 ret
= mlx4_ACCESS_PTYS_REG(priv
->mdev
->dev
, MLX4_ACCESS_REG_WRITE
,
969 en_warn(priv
, "Failed to write mlx4_ACCESS_PTYS_REG eth_proto_admin(0x%x) status(0x%x)",
970 be32_to_cpu(ptys_reg
.eth_proto_admin
), ret
);
974 mutex_lock(&priv
->mdev
->state_lock
);
976 en_warn(priv
, "Port link mode changed, restarting port...\n");
977 mlx4_en_stop_port(dev
, 1);
978 if (mlx4_en_start_port(dev
))
979 en_err(priv
, "Failed restarting port %d\n", priv
->port
);
981 mutex_unlock(&priv
->mdev
->state_lock
);
985 static int mlx4_en_get_coalesce(struct net_device
*dev
,
986 struct ethtool_coalesce
*coal
)
988 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
990 coal
->tx_coalesce_usecs
= priv
->tx_usecs
;
991 coal
->tx_max_coalesced_frames
= priv
->tx_frames
;
992 coal
->tx_max_coalesced_frames_irq
= priv
->tx_work_limit
;
994 coal
->rx_coalesce_usecs
= priv
->rx_usecs
;
995 coal
->rx_max_coalesced_frames
= priv
->rx_frames
;
997 coal
->pkt_rate_low
= priv
->pkt_rate_low
;
998 coal
->rx_coalesce_usecs_low
= priv
->rx_usecs_low
;
999 coal
->pkt_rate_high
= priv
->pkt_rate_high
;
1000 coal
->rx_coalesce_usecs_high
= priv
->rx_usecs_high
;
1001 coal
->rate_sample_interval
= priv
->sample_interval
;
1002 coal
->use_adaptive_rx_coalesce
= priv
->adaptive_rx_coal
;
1007 static int mlx4_en_set_coalesce(struct net_device
*dev
,
1008 struct ethtool_coalesce
*coal
)
1010 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1012 if (!coal
->tx_max_coalesced_frames_irq
)
1015 priv
->rx_frames
= (coal
->rx_max_coalesced_frames
==
1016 MLX4_EN_AUTO_CONF
) ?
1017 MLX4_EN_RX_COAL_TARGET
:
1018 coal
->rx_max_coalesced_frames
;
1019 priv
->rx_usecs
= (coal
->rx_coalesce_usecs
==
1020 MLX4_EN_AUTO_CONF
) ?
1021 MLX4_EN_RX_COAL_TIME
:
1022 coal
->rx_coalesce_usecs
;
1024 /* Setting TX coalescing parameters */
1025 if (coal
->tx_coalesce_usecs
!= priv
->tx_usecs
||
1026 coal
->tx_max_coalesced_frames
!= priv
->tx_frames
) {
1027 priv
->tx_usecs
= coal
->tx_coalesce_usecs
;
1028 priv
->tx_frames
= coal
->tx_max_coalesced_frames
;
1031 /* Set adaptive coalescing params */
1032 priv
->pkt_rate_low
= coal
->pkt_rate_low
;
1033 priv
->rx_usecs_low
= coal
->rx_coalesce_usecs_low
;
1034 priv
->pkt_rate_high
= coal
->pkt_rate_high
;
1035 priv
->rx_usecs_high
= coal
->rx_coalesce_usecs_high
;
1036 priv
->sample_interval
= coal
->rate_sample_interval
;
1037 priv
->adaptive_rx_coal
= coal
->use_adaptive_rx_coalesce
;
1038 priv
->tx_work_limit
= coal
->tx_max_coalesced_frames_irq
;
1040 return mlx4_en_moderation_update(priv
);
1043 static int mlx4_en_set_pauseparam(struct net_device
*dev
,
1044 struct ethtool_pauseparam
*pause
)
1046 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1047 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1053 priv
->prof
->tx_pause
= pause
->tx_pause
!= 0;
1054 priv
->prof
->rx_pause
= pause
->rx_pause
!= 0;
1055 err
= mlx4_SET_PORT_general(mdev
->dev
, priv
->port
,
1056 priv
->rx_skb_size
+ ETH_FCS_LEN
,
1057 priv
->prof
->tx_pause
,
1059 priv
->prof
->rx_pause
,
1060 priv
->prof
->rx_ppp
);
1062 en_err(priv
, "Failed setting pause params\n");
1064 mlx4_en_update_pfc_stats_bitmap(mdev
->dev
, &priv
->stats_bitmap
,
1066 priv
->prof
->rx_pause
,
1068 priv
->prof
->tx_pause
);
1073 static void mlx4_en_get_pauseparam(struct net_device
*dev
,
1074 struct ethtool_pauseparam
*pause
)
1076 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1078 pause
->tx_pause
= priv
->prof
->tx_pause
;
1079 pause
->rx_pause
= priv
->prof
->rx_pause
;
1082 static int mlx4_en_set_ringparam(struct net_device
*dev
,
1083 struct ethtool_ringparam
*param
)
1085 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1086 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1087 struct mlx4_en_port_profile new_prof
;
1088 struct mlx4_en_priv
*tmp
;
1089 u32 rx_size
, tx_size
;
1093 if (param
->rx_jumbo_pending
|| param
->rx_mini_pending
)
1096 rx_size
= roundup_pow_of_two(param
->rx_pending
);
1097 rx_size
= max_t(u32
, rx_size
, MLX4_EN_MIN_RX_SIZE
);
1098 rx_size
= min_t(u32
, rx_size
, MLX4_EN_MAX_RX_SIZE
);
1099 tx_size
= roundup_pow_of_two(param
->tx_pending
);
1100 tx_size
= max_t(u32
, tx_size
, MLX4_EN_MIN_TX_SIZE
);
1101 tx_size
= min_t(u32
, tx_size
, MLX4_EN_MAX_TX_SIZE
);
1103 if (rx_size
== (priv
->port_up
? priv
->rx_ring
[0]->actual_size
:
1104 priv
->rx_ring
[0]->size
) &&
1105 tx_size
== priv
->tx_ring
[TX
][0]->size
)
1108 tmp
= kzalloc(sizeof(*tmp
), GFP_KERNEL
);
1112 mutex_lock(&mdev
->state_lock
);
1113 memcpy(&new_prof
, priv
->prof
, sizeof(struct mlx4_en_port_profile
));
1114 new_prof
.tx_ring_size
= tx_size
;
1115 new_prof
.rx_ring_size
= rx_size
;
1116 err
= mlx4_en_try_alloc_resources(priv
, tmp
, &new_prof
, true);
1120 if (priv
->port_up
) {
1122 mlx4_en_stop_port(dev
, 1);
1125 mlx4_en_safe_replace_resources(priv
, tmp
);
1128 err
= mlx4_en_start_port(dev
);
1130 en_err(priv
, "Failed starting port\n");
1133 err
= mlx4_en_moderation_update(priv
);
1136 mutex_unlock(&mdev
->state_lock
);
1140 static void mlx4_en_get_ringparam(struct net_device
*dev
,
1141 struct ethtool_ringparam
*param
)
1143 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1145 memset(param
, 0, sizeof(*param
));
1146 param
->rx_max_pending
= MLX4_EN_MAX_RX_SIZE
;
1147 param
->tx_max_pending
= MLX4_EN_MAX_TX_SIZE
;
1148 param
->rx_pending
= priv
->port_up
?
1149 priv
->rx_ring
[0]->actual_size
: priv
->rx_ring
[0]->size
;
1150 param
->tx_pending
= priv
->tx_ring
[TX
][0]->size
;
1153 static u32
mlx4_en_get_rxfh_indir_size(struct net_device
*dev
)
1155 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1157 return rounddown_pow_of_two(priv
->rx_ring_num
);
1160 static u32
mlx4_en_get_rxfh_key_size(struct net_device
*netdev
)
1162 return MLX4_EN_RSS_KEY_SIZE
;
1165 static int mlx4_en_check_rxfh_func(struct net_device
*dev
, u8 hfunc
)
1167 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1169 /* check if requested function is supported by the device */
1170 if (hfunc
== ETH_RSS_HASH_TOP
) {
1171 if (!(priv
->mdev
->dev
->caps
.flags2
& MLX4_DEV_CAP_FLAG2_RSS_TOP
))
1173 if (!(dev
->features
& NETIF_F_RXHASH
))
1174 en_warn(priv
, "Toeplitz hash function should be used in conjunction with RX hashing for optimal performance\n");
1176 } else if (hfunc
== ETH_RSS_HASH_XOR
) {
1177 if (!(priv
->mdev
->dev
->caps
.flags2
& MLX4_DEV_CAP_FLAG2_RSS_XOR
))
1179 if (dev
->features
& NETIF_F_RXHASH
)
1180 en_warn(priv
, "Enabling both XOR Hash function and RX Hashing can limit RPS functionality\n");
1187 static int mlx4_en_get_rxfh(struct net_device
*dev
, u32
*ring_index
, u8
*key
,
1190 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1191 u32 n
= mlx4_en_get_rxfh_indir_size(dev
);
1195 rss_rings
= priv
->prof
->rss_rings
?: n
;
1196 rss_rings
= rounddown_pow_of_two(rss_rings
);
1198 for (i
= 0; i
< n
; i
++) {
1201 ring_index
[i
] = i
% rss_rings
;
1204 memcpy(key
, priv
->rss_key
, MLX4_EN_RSS_KEY_SIZE
);
1206 *hfunc
= priv
->rss_hash_fn
;
1210 static int mlx4_en_set_rxfh(struct net_device
*dev
, const u32
*ring_index
,
1211 const u8
*key
, const u8 hfunc
)
1213 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1214 u32 n
= mlx4_en_get_rxfh_indir_size(dev
);
1215 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1221 /* Calculate RSS table size and make sure flows are spread evenly
1224 for (i
= 0; i
< n
; i
++) {
1227 if (i
> 0 && !ring_index
[i
] && !rss_rings
)
1230 if (ring_index
[i
] != (i
% (rss_rings
?: n
)))
1237 /* RSS table size must be an order of 2 */
1238 if (!is_power_of_2(rss_rings
))
1241 if (hfunc
!= ETH_RSS_HASH_NO_CHANGE
) {
1242 err
= mlx4_en_check_rxfh_func(dev
, hfunc
);
1247 mutex_lock(&mdev
->state_lock
);
1248 if (priv
->port_up
) {
1250 mlx4_en_stop_port(dev
, 1);
1254 priv
->prof
->rss_rings
= rss_rings
;
1256 memcpy(priv
->rss_key
, key
, MLX4_EN_RSS_KEY_SIZE
);
1257 if (hfunc
!= ETH_RSS_HASH_NO_CHANGE
)
1258 priv
->rss_hash_fn
= hfunc
;
1261 err
= mlx4_en_start_port(dev
);
1263 en_err(priv
, "Failed starting port\n");
1266 mutex_unlock(&mdev
->state_lock
);
1270 #define all_zeros_or_all_ones(field) \
1271 ((field) == 0 || (field) == (__force typeof(field))-1)
1273 static int mlx4_en_validate_flow(struct net_device
*dev
,
1274 struct ethtool_rxnfc
*cmd
)
1276 struct ethtool_usrip4_spec
*l3_mask
;
1277 struct ethtool_tcpip4_spec
*l4_mask
;
1278 struct ethhdr
*eth_mask
;
1280 if (cmd
->fs
.location
>= MAX_NUM_OF_FS_RULES
)
1283 if (cmd
->fs
.flow_type
& FLOW_MAC_EXT
) {
1284 /* dest mac mask must be ff:ff:ff:ff:ff:ff */
1285 if (!is_broadcast_ether_addr(cmd
->fs
.m_ext
.h_dest
))
1289 switch (cmd
->fs
.flow_type
& ~(FLOW_EXT
| FLOW_MAC_EXT
)) {
1292 if (cmd
->fs
.m_u
.tcp_ip4_spec
.tos
)
1294 l4_mask
= &cmd
->fs
.m_u
.tcp_ip4_spec
;
1295 /* don't allow mask which isn't all 0 or 1 */
1296 if (!all_zeros_or_all_ones(l4_mask
->ip4src
) ||
1297 !all_zeros_or_all_ones(l4_mask
->ip4dst
) ||
1298 !all_zeros_or_all_ones(l4_mask
->psrc
) ||
1299 !all_zeros_or_all_ones(l4_mask
->pdst
))
1303 l3_mask
= &cmd
->fs
.m_u
.usr_ip4_spec
;
1304 if (l3_mask
->l4_4_bytes
|| l3_mask
->tos
|| l3_mask
->proto
||
1305 cmd
->fs
.h_u
.usr_ip4_spec
.ip_ver
!= ETH_RX_NFC_IP4
||
1306 (!l3_mask
->ip4src
&& !l3_mask
->ip4dst
) ||
1307 !all_zeros_or_all_ones(l3_mask
->ip4src
) ||
1308 !all_zeros_or_all_ones(l3_mask
->ip4dst
))
1312 eth_mask
= &cmd
->fs
.m_u
.ether_spec
;
1313 /* source mac mask must not be set */
1314 if (!is_zero_ether_addr(eth_mask
->h_source
))
1317 /* dest mac mask must be ff:ff:ff:ff:ff:ff */
1318 if (!is_broadcast_ether_addr(eth_mask
->h_dest
))
1321 if (!all_zeros_or_all_ones(eth_mask
->h_proto
))
1328 if ((cmd
->fs
.flow_type
& FLOW_EXT
)) {
1329 if (cmd
->fs
.m_ext
.vlan_etype
||
1330 !((cmd
->fs
.m_ext
.vlan_tci
& cpu_to_be16(VLAN_VID_MASK
)) ==
1332 (cmd
->fs
.m_ext
.vlan_tci
& cpu_to_be16(VLAN_VID_MASK
)) ==
1333 cpu_to_be16(VLAN_VID_MASK
)))
1336 if (cmd
->fs
.m_ext
.vlan_tci
) {
1337 if (be16_to_cpu(cmd
->fs
.h_ext
.vlan_tci
) >= VLAN_N_VID
)
1346 static int mlx4_en_ethtool_add_mac_rule(struct ethtool_rxnfc
*cmd
,
1347 struct list_head
*rule_list_h
,
1348 struct mlx4_spec_list
*spec_l2
,
1352 __be64 mac_msk
= cpu_to_be64(MLX4_MAC_MASK
<< 16);
1354 spec_l2
->id
= MLX4_NET_TRANS_RULE_ID_ETH
;
1355 memcpy(spec_l2
->eth
.dst_mac_msk
, &mac_msk
, ETH_ALEN
);
1356 memcpy(spec_l2
->eth
.dst_mac
, mac
, ETH_ALEN
);
1358 if ((cmd
->fs
.flow_type
& FLOW_EXT
) &&
1359 (cmd
->fs
.m_ext
.vlan_tci
& cpu_to_be16(VLAN_VID_MASK
))) {
1360 spec_l2
->eth
.vlan_id
= cmd
->fs
.h_ext
.vlan_tci
;
1361 spec_l2
->eth
.vlan_id_msk
= cpu_to_be16(VLAN_VID_MASK
);
1364 list_add_tail(&spec_l2
->list
, rule_list_h
);
1369 static int mlx4_en_ethtool_add_mac_rule_by_ipv4(struct mlx4_en_priv
*priv
,
1370 struct ethtool_rxnfc
*cmd
,
1371 struct list_head
*rule_list_h
,
1372 struct mlx4_spec_list
*spec_l2
,
1376 unsigned char mac
[ETH_ALEN
];
1378 if (!ipv4_is_multicast(ipv4_dst
)) {
1379 if (cmd
->fs
.flow_type
& FLOW_MAC_EXT
)
1380 memcpy(&mac
, cmd
->fs
.h_ext
.h_dest
, ETH_ALEN
);
1382 memcpy(&mac
, priv
->dev
->dev_addr
, ETH_ALEN
);
1384 ip_eth_mc_map(ipv4_dst
, mac
);
1387 return mlx4_en_ethtool_add_mac_rule(cmd
, rule_list_h
, spec_l2
, &mac
[0]);
1393 static int add_ip_rule(struct mlx4_en_priv
*priv
,
1394 struct ethtool_rxnfc
*cmd
,
1395 struct list_head
*list_h
)
1398 struct mlx4_spec_list
*spec_l2
= NULL
;
1399 struct mlx4_spec_list
*spec_l3
= NULL
;
1400 struct ethtool_usrip4_spec
*l3_mask
= &cmd
->fs
.m_u
.usr_ip4_spec
;
1402 spec_l3
= kzalloc(sizeof(*spec_l3
), GFP_KERNEL
);
1403 spec_l2
= kzalloc(sizeof(*spec_l2
), GFP_KERNEL
);
1404 if (!spec_l2
|| !spec_l3
) {
1409 err
= mlx4_en_ethtool_add_mac_rule_by_ipv4(priv
, cmd
, list_h
, spec_l2
,
1411 usr_ip4_spec
.ip4dst
);
1414 spec_l3
->id
= MLX4_NET_TRANS_RULE_ID_IPV4
;
1415 spec_l3
->ipv4
.src_ip
= cmd
->fs
.h_u
.usr_ip4_spec
.ip4src
;
1416 if (l3_mask
->ip4src
)
1417 spec_l3
->ipv4
.src_ip_msk
= EN_ETHTOOL_WORD_MASK
;
1418 spec_l3
->ipv4
.dst_ip
= cmd
->fs
.h_u
.usr_ip4_spec
.ip4dst
;
1419 if (l3_mask
->ip4dst
)
1420 spec_l3
->ipv4
.dst_ip_msk
= EN_ETHTOOL_WORD_MASK
;
1421 list_add_tail(&spec_l3
->list
, list_h
);
1431 static int add_tcp_udp_rule(struct mlx4_en_priv
*priv
,
1432 struct ethtool_rxnfc
*cmd
,
1433 struct list_head
*list_h
, int proto
)
1436 struct mlx4_spec_list
*spec_l2
= NULL
;
1437 struct mlx4_spec_list
*spec_l3
= NULL
;
1438 struct mlx4_spec_list
*spec_l4
= NULL
;
1439 struct ethtool_tcpip4_spec
*l4_mask
= &cmd
->fs
.m_u
.tcp_ip4_spec
;
1441 spec_l2
= kzalloc(sizeof(*spec_l2
), GFP_KERNEL
);
1442 spec_l3
= kzalloc(sizeof(*spec_l3
), GFP_KERNEL
);
1443 spec_l4
= kzalloc(sizeof(*spec_l4
), GFP_KERNEL
);
1444 if (!spec_l2
|| !spec_l3
|| !spec_l4
) {
1449 spec_l3
->id
= MLX4_NET_TRANS_RULE_ID_IPV4
;
1451 if (proto
== TCP_V4_FLOW
) {
1452 err
= mlx4_en_ethtool_add_mac_rule_by_ipv4(priv
, cmd
, list_h
,
1455 tcp_ip4_spec
.ip4dst
);
1458 spec_l4
->id
= MLX4_NET_TRANS_RULE_ID_TCP
;
1459 spec_l3
->ipv4
.src_ip
= cmd
->fs
.h_u
.tcp_ip4_spec
.ip4src
;
1460 spec_l3
->ipv4
.dst_ip
= cmd
->fs
.h_u
.tcp_ip4_spec
.ip4dst
;
1461 spec_l4
->tcp_udp
.src_port
= cmd
->fs
.h_u
.tcp_ip4_spec
.psrc
;
1462 spec_l4
->tcp_udp
.dst_port
= cmd
->fs
.h_u
.tcp_ip4_spec
.pdst
;
1464 err
= mlx4_en_ethtool_add_mac_rule_by_ipv4(priv
, cmd
, list_h
,
1467 udp_ip4_spec
.ip4dst
);
1470 spec_l4
->id
= MLX4_NET_TRANS_RULE_ID_UDP
;
1471 spec_l3
->ipv4
.src_ip
= cmd
->fs
.h_u
.udp_ip4_spec
.ip4src
;
1472 spec_l3
->ipv4
.dst_ip
= cmd
->fs
.h_u
.udp_ip4_spec
.ip4dst
;
1473 spec_l4
->tcp_udp
.src_port
= cmd
->fs
.h_u
.udp_ip4_spec
.psrc
;
1474 spec_l4
->tcp_udp
.dst_port
= cmd
->fs
.h_u
.udp_ip4_spec
.pdst
;
1477 if (l4_mask
->ip4src
)
1478 spec_l3
->ipv4
.src_ip_msk
= EN_ETHTOOL_WORD_MASK
;
1479 if (l4_mask
->ip4dst
)
1480 spec_l3
->ipv4
.dst_ip_msk
= EN_ETHTOOL_WORD_MASK
;
1483 spec_l4
->tcp_udp
.src_port_msk
= EN_ETHTOOL_SHORT_MASK
;
1485 spec_l4
->tcp_udp
.dst_port_msk
= EN_ETHTOOL_SHORT_MASK
;
1487 list_add_tail(&spec_l3
->list
, list_h
);
1488 list_add_tail(&spec_l4
->list
, list_h
);
1499 static int mlx4_en_ethtool_to_net_trans_rule(struct net_device
*dev
,
1500 struct ethtool_rxnfc
*cmd
,
1501 struct list_head
*rule_list_h
)
1504 struct ethhdr
*eth_spec
;
1505 struct mlx4_spec_list
*spec_l2
;
1506 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1508 err
= mlx4_en_validate_flow(dev
, cmd
);
1512 switch (cmd
->fs
.flow_type
& ~(FLOW_EXT
| FLOW_MAC_EXT
)) {
1514 spec_l2
= kzalloc(sizeof(*spec_l2
), GFP_KERNEL
);
1518 eth_spec
= &cmd
->fs
.h_u
.ether_spec
;
1519 mlx4_en_ethtool_add_mac_rule(cmd
, rule_list_h
, spec_l2
,
1520 ð_spec
->h_dest
[0]);
1521 spec_l2
->eth
.ether_type
= eth_spec
->h_proto
;
1522 if (eth_spec
->h_proto
)
1523 spec_l2
->eth
.ether_type_enable
= 1;
1526 err
= add_ip_rule(priv
, cmd
, rule_list_h
);
1529 err
= add_tcp_udp_rule(priv
, cmd
, rule_list_h
, TCP_V4_FLOW
);
1532 err
= add_tcp_udp_rule(priv
, cmd
, rule_list_h
, UDP_V4_FLOW
);
1539 static int mlx4_en_flow_replace(struct net_device
*dev
,
1540 struct ethtool_rxnfc
*cmd
)
1543 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1544 struct ethtool_flow_id
*loc_rule
;
1545 struct mlx4_spec_list
*spec
, *tmp_spec
;
1549 struct mlx4_net_trans_rule rule
= {
1550 .queue_mode
= MLX4_NET_TRANS_Q_FIFO
,
1552 .allow_loopback
= 1,
1553 .promisc_mode
= MLX4_FS_REGULAR
,
1556 rule
.port
= priv
->port
;
1557 rule
.priority
= MLX4_DOMAIN_ETHTOOL
| cmd
->fs
.location
;
1558 INIT_LIST_HEAD(&rule
.list
);
1560 /* Allow direct QP attaches if the EN_ETHTOOL_QP_ATTACH flag is set */
1561 if (cmd
->fs
.ring_cookie
== RX_CLS_FLOW_DISC
)
1562 qpn
= priv
->drop_qp
.qpn
;
1563 else if (cmd
->fs
.ring_cookie
& EN_ETHTOOL_QP_ATTACH
) {
1564 qpn
= cmd
->fs
.ring_cookie
& (EN_ETHTOOL_QP_ATTACH
- 1);
1566 if (cmd
->fs
.ring_cookie
>= priv
->rx_ring_num
) {
1567 en_warn(priv
, "rxnfc: RX ring (%llu) doesn't exist\n",
1568 cmd
->fs
.ring_cookie
);
1571 qpn
= priv
->rss_map
.qps
[cmd
->fs
.ring_cookie
].qpn
;
1573 en_warn(priv
, "rxnfc: RX ring (%llu) is inactive\n",
1574 cmd
->fs
.ring_cookie
);
1579 err
= mlx4_en_ethtool_to_net_trans_rule(dev
, cmd
, &rule
.list
);
1583 loc_rule
= &priv
->ethtool_rules
[cmd
->fs
.location
];
1585 err
= mlx4_flow_detach(priv
->mdev
->dev
, loc_rule
->id
);
1587 en_err(priv
, "Fail to detach network rule at location %d. registration id = %llx\n",
1588 cmd
->fs
.location
, loc_rule
->id
);
1592 memset(&loc_rule
->flow_spec
, 0,
1593 sizeof(struct ethtool_rx_flow_spec
));
1594 list_del(&loc_rule
->list
);
1596 err
= mlx4_flow_attach(priv
->mdev
->dev
, &rule
, ®_id
);
1598 en_err(priv
, "Fail to attach network rule at location %d\n",
1602 loc_rule
->id
= reg_id
;
1603 memcpy(&loc_rule
->flow_spec
, &cmd
->fs
,
1604 sizeof(struct ethtool_rx_flow_spec
));
1605 list_add_tail(&loc_rule
->list
, &priv
->ethtool_list
);
1608 list_for_each_entry_safe(spec
, tmp_spec
, &rule
.list
, list
) {
1609 list_del(&spec
->list
);
1615 static int mlx4_en_flow_detach(struct net_device
*dev
,
1616 struct ethtool_rxnfc
*cmd
)
1619 struct ethtool_flow_id
*rule
;
1620 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1622 if (cmd
->fs
.location
>= MAX_NUM_OF_FS_RULES
)
1625 rule
= &priv
->ethtool_rules
[cmd
->fs
.location
];
1631 err
= mlx4_flow_detach(priv
->mdev
->dev
, rule
->id
);
1633 en_err(priv
, "Fail to detach network rule at location %d. registration id = 0x%llx\n",
1634 cmd
->fs
.location
, rule
->id
);
1638 memset(&rule
->flow_spec
, 0, sizeof(struct ethtool_rx_flow_spec
));
1639 list_del(&rule
->list
);
1645 static int mlx4_en_get_flow(struct net_device
*dev
, struct ethtool_rxnfc
*cmd
,
1649 struct ethtool_flow_id
*rule
;
1650 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1652 if (loc
< 0 || loc
>= MAX_NUM_OF_FS_RULES
)
1655 rule
= &priv
->ethtool_rules
[loc
];
1657 memcpy(&cmd
->fs
, &rule
->flow_spec
,
1658 sizeof(struct ethtool_rx_flow_spec
));
1665 static int mlx4_en_get_num_flows(struct mlx4_en_priv
*priv
)
1669 for (i
= 0; i
< MAX_NUM_OF_FS_RULES
; i
++) {
1670 if (priv
->ethtool_rules
[i
].id
)
1677 static int mlx4_en_get_rxnfc(struct net_device
*dev
, struct ethtool_rxnfc
*cmd
,
1680 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1681 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1683 int i
= 0, priority
= 0;
1685 if ((cmd
->cmd
== ETHTOOL_GRXCLSRLCNT
||
1686 cmd
->cmd
== ETHTOOL_GRXCLSRULE
||
1687 cmd
->cmd
== ETHTOOL_GRXCLSRLALL
) &&
1688 (mdev
->dev
->caps
.steering_mode
!=
1689 MLX4_STEERING_MODE_DEVICE_MANAGED
|| !priv
->port_up
))
1693 case ETHTOOL_GRXRINGS
:
1694 cmd
->data
= priv
->rx_ring_num
;
1696 case ETHTOOL_GRXCLSRLCNT
:
1697 cmd
->rule_cnt
= mlx4_en_get_num_flows(priv
);
1699 case ETHTOOL_GRXCLSRULE
:
1700 err
= mlx4_en_get_flow(dev
, cmd
, cmd
->fs
.location
);
1702 case ETHTOOL_GRXCLSRLALL
:
1703 while ((!err
|| err
== -ENOENT
) && priority
< cmd
->rule_cnt
) {
1704 err
= mlx4_en_get_flow(dev
, cmd
, i
);
1706 rule_locs
[priority
++] = i
;
1719 static int mlx4_en_set_rxnfc(struct net_device
*dev
, struct ethtool_rxnfc
*cmd
)
1722 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1723 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1725 if (mdev
->dev
->caps
.steering_mode
!=
1726 MLX4_STEERING_MODE_DEVICE_MANAGED
|| !priv
->port_up
)
1730 case ETHTOOL_SRXCLSRLINS
:
1731 err
= mlx4_en_flow_replace(dev
, cmd
);
1733 case ETHTOOL_SRXCLSRLDEL
:
1734 err
= mlx4_en_flow_detach(dev
, cmd
);
1737 en_warn(priv
, "Unsupported ethtool command. (%d)\n", cmd
->cmd
);
1744 static void mlx4_en_get_channels(struct net_device
*dev
,
1745 struct ethtool_channels
*channel
)
1747 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1749 channel
->max_rx
= MAX_RX_RINGS
;
1750 channel
->max_tx
= MLX4_EN_MAX_TX_RING_P_UP
;
1752 channel
->rx_count
= priv
->rx_ring_num
;
1753 channel
->tx_count
= priv
->tx_ring_num
[TX
] /
1757 static int mlx4_en_set_channels(struct net_device
*dev
,
1758 struct ethtool_channels
*channel
)
1760 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1761 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1762 struct mlx4_en_port_profile new_prof
;
1763 struct mlx4_en_priv
*tmp
;
1769 if (!channel
->tx_count
|| !channel
->rx_count
)
1772 tmp
= kzalloc(sizeof(*tmp
), GFP_KERNEL
);
1776 mutex_lock(&mdev
->state_lock
);
1777 xdp_count
= priv
->tx_ring_num
[TX_XDP
] ? channel
->rx_count
: 0;
1778 if (channel
->tx_count
* priv
->prof
->num_up
+ xdp_count
>
1782 "Total number of TX and XDP rings (%d) exceeds the maximum supported (%d)\n",
1783 channel
->tx_count
* priv
->prof
->num_up
+ xdp_count
,
1788 memcpy(&new_prof
, priv
->prof
, sizeof(struct mlx4_en_port_profile
));
1789 new_prof
.num_tx_rings_p_up
= channel
->tx_count
;
1790 new_prof
.tx_ring_num
[TX
] = channel
->tx_count
* priv
->prof
->num_up
;
1791 new_prof
.tx_ring_num
[TX_XDP
] = xdp_count
;
1792 new_prof
.rx_ring_num
= channel
->rx_count
;
1794 err
= mlx4_en_try_alloc_resources(priv
, tmp
, &new_prof
, true);
1798 if (priv
->port_up
) {
1800 mlx4_en_stop_port(dev
, 1);
1803 mlx4_en_safe_replace_resources(priv
, tmp
);
1805 netif_set_real_num_rx_queues(dev
, priv
->rx_ring_num
);
1807 up
= (priv
->prof
->num_up
== MLX4_EN_NUM_UP_LOW
) ?
1808 0 : priv
->prof
->num_up
;
1809 mlx4_en_setup_tc(dev
, up
);
1811 en_warn(priv
, "Using %d TX rings\n", priv
->tx_ring_num
[TX
]);
1812 en_warn(priv
, "Using %d RX rings\n", priv
->rx_ring_num
);
1815 err
= mlx4_en_start_port(dev
);
1817 en_err(priv
, "Failed starting port\n");
1820 err
= mlx4_en_moderation_update(priv
);
1822 mutex_unlock(&mdev
->state_lock
);
1827 static int mlx4_en_get_ts_info(struct net_device
*dev
,
1828 struct ethtool_ts_info
*info
)
1830 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1831 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1834 ret
= ethtool_op_get_ts_info(dev
, info
);
1838 if (mdev
->dev
->caps
.flags2
& MLX4_DEV_CAP_FLAG2_TS
) {
1839 info
->so_timestamping
|=
1840 SOF_TIMESTAMPING_TX_HARDWARE
|
1841 SOF_TIMESTAMPING_RX_HARDWARE
|
1842 SOF_TIMESTAMPING_RAW_HARDWARE
;
1845 (1 << HWTSTAMP_TX_OFF
) |
1846 (1 << HWTSTAMP_TX_ON
);
1849 (1 << HWTSTAMP_FILTER_NONE
) |
1850 (1 << HWTSTAMP_FILTER_ALL
);
1852 if (mdev
->ptp_clock
)
1853 info
->phc_index
= ptp_clock_index(mdev
->ptp_clock
);
1859 static int mlx4_en_set_priv_flags(struct net_device
*dev
, u32 flags
)
1861 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1862 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1863 bool bf_enabled_new
= !!(flags
& MLX4_EN_PRIV_FLAGS_BLUEFLAME
);
1864 bool bf_enabled_old
= !!(priv
->pflags
& MLX4_EN_PRIV_FLAGS_BLUEFLAME
);
1865 bool phv_enabled_new
= !!(flags
& MLX4_EN_PRIV_FLAGS_PHV
);
1866 bool phv_enabled_old
= !!(priv
->pflags
& MLX4_EN_PRIV_FLAGS_PHV
);
1870 if (bf_enabled_new
!= bf_enabled_old
) {
1873 if (bf_enabled_new
) {
1874 bool bf_supported
= true;
1876 for (t
= 0; t
< MLX4_EN_NUM_TX_TYPES
; t
++)
1877 for (i
= 0; i
< priv
->tx_ring_num
[t
]; i
++)
1879 priv
->tx_ring
[t
][i
]->bf_alloced
;
1881 if (!bf_supported
) {
1882 en_err(priv
, "BlueFlame is not supported\n");
1886 priv
->pflags
|= MLX4_EN_PRIV_FLAGS_BLUEFLAME
;
1888 priv
->pflags
&= ~MLX4_EN_PRIV_FLAGS_BLUEFLAME
;
1891 for (t
= 0; t
< MLX4_EN_NUM_TX_TYPES
; t
++)
1892 for (i
= 0; i
< priv
->tx_ring_num
[t
]; i
++)
1893 priv
->tx_ring
[t
][i
]->bf_enabled
=
1896 en_info(priv
, "BlueFlame %s\n",
1897 bf_enabled_new
? "Enabled" : "Disabled");
1900 if (phv_enabled_new
!= phv_enabled_old
) {
1901 ret
= set_phv_bit(mdev
->dev
, priv
->port
, (int)phv_enabled_new
);
1904 else if (phv_enabled_new
)
1905 priv
->pflags
|= MLX4_EN_PRIV_FLAGS_PHV
;
1907 priv
->pflags
&= ~MLX4_EN_PRIV_FLAGS_PHV
;
1908 en_info(priv
, "PHV bit %s\n",
1909 phv_enabled_new
? "Enabled" : "Disabled");
1914 static u32
mlx4_en_get_priv_flags(struct net_device
*dev
)
1916 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1918 return priv
->pflags
;
1921 static int mlx4_en_get_tunable(struct net_device
*dev
,
1922 const struct ethtool_tunable
*tuna
,
1925 const struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1929 case ETHTOOL_TX_COPYBREAK
:
1930 *(u32
*)data
= priv
->prof
->inline_thold
;
1940 static int mlx4_en_set_tunable(struct net_device
*dev
,
1941 const struct ethtool_tunable
*tuna
,
1944 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1948 case ETHTOOL_TX_COPYBREAK
:
1950 if (val
< MIN_PKT_LEN
|| val
> MAX_INLINE
)
1953 priv
->prof
->inline_thold
= val
;
1963 static int mlx4_en_get_module_info(struct net_device
*dev
,
1964 struct ethtool_modinfo
*modinfo
)
1966 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1967 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1971 /* Read first 2 bytes to get Module & REV ID */
1972 ret
= mlx4_get_module_info(mdev
->dev
, priv
->port
,
1973 0/*offset*/, 2/*size*/, data
);
1977 switch (data
[0] /* identifier */) {
1978 case MLX4_MODULE_ID_QSFP
:
1979 modinfo
->type
= ETH_MODULE_SFF_8436
;
1980 modinfo
->eeprom_len
= ETH_MODULE_SFF_8436_LEN
;
1982 case MLX4_MODULE_ID_QSFP_PLUS
:
1983 if (data
[1] >= 0x3) { /* revision id */
1984 modinfo
->type
= ETH_MODULE_SFF_8636
;
1985 modinfo
->eeprom_len
= ETH_MODULE_SFF_8636_LEN
;
1987 modinfo
->type
= ETH_MODULE_SFF_8436
;
1988 modinfo
->eeprom_len
= ETH_MODULE_SFF_8436_LEN
;
1991 case MLX4_MODULE_ID_QSFP28
:
1992 modinfo
->type
= ETH_MODULE_SFF_8636
;
1993 modinfo
->eeprom_len
= ETH_MODULE_SFF_8636_LEN
;
1995 case MLX4_MODULE_ID_SFP
:
1996 modinfo
->type
= ETH_MODULE_SFF_8472
;
1997 modinfo
->eeprom_len
= ETH_MODULE_SFF_8472_LEN
;
2006 static int mlx4_en_get_module_eeprom(struct net_device
*dev
,
2007 struct ethtool_eeprom
*ee
,
2010 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
2011 struct mlx4_en_dev
*mdev
= priv
->mdev
;
2012 int offset
= ee
->offset
;
2018 memset(data
, 0, ee
->len
);
2020 while (i
< ee
->len
) {
2022 "mlx4_get_module_info i(%d) offset(%d) len(%d)\n",
2023 i
, offset
, ee
->len
- i
);
2025 ret
= mlx4_get_module_info(mdev
->dev
, priv
->port
,
2026 offset
, ee
->len
- i
, data
+ i
);
2028 if (!ret
) /* Done reading */
2033 "mlx4_get_module_info i(%d) offset(%d) bytes_to_read(%d) - FAILED (0x%x)\n",
2034 i
, offset
, ee
->len
- i
, ret
);
2044 static int mlx4_en_set_phys_id(struct net_device
*dev
,
2045 enum ethtool_phys_id_state state
)
2048 u16 beacon_duration
;
2049 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
2050 struct mlx4_en_dev
*mdev
= priv
->mdev
;
2052 if (!(mdev
->dev
->caps
.flags2
& MLX4_DEV_CAP_FLAG2_PORT_BEACON
))
2056 case ETHTOOL_ID_ACTIVE
:
2057 beacon_duration
= PORT_BEACON_MAX_LIMIT
;
2059 case ETHTOOL_ID_INACTIVE
:
2060 beacon_duration
= 0;
2066 err
= mlx4_SET_PORT_BEACON(mdev
->dev
, priv
->port
, beacon_duration
);
2070 const struct ethtool_ops mlx4_en_ethtool_ops
= {
2071 .get_drvinfo
= mlx4_en_get_drvinfo
,
2072 .get_link_ksettings
= mlx4_en_get_link_ksettings
,
2073 .set_link_ksettings
= mlx4_en_set_link_ksettings
,
2074 .get_link
= ethtool_op_get_link
,
2075 .get_strings
= mlx4_en_get_strings
,
2076 .get_sset_count
= mlx4_en_get_sset_count
,
2077 .get_ethtool_stats
= mlx4_en_get_ethtool_stats
,
2078 .self_test
= mlx4_en_self_test
,
2079 .set_phys_id
= mlx4_en_set_phys_id
,
2080 .get_wol
= mlx4_en_get_wol
,
2081 .set_wol
= mlx4_en_set_wol
,
2082 .get_msglevel
= mlx4_en_get_msglevel
,
2083 .set_msglevel
= mlx4_en_set_msglevel
,
2084 .get_coalesce
= mlx4_en_get_coalesce
,
2085 .set_coalesce
= mlx4_en_set_coalesce
,
2086 .get_pauseparam
= mlx4_en_get_pauseparam
,
2087 .set_pauseparam
= mlx4_en_set_pauseparam
,
2088 .get_ringparam
= mlx4_en_get_ringparam
,
2089 .set_ringparam
= mlx4_en_set_ringparam
,
2090 .get_rxnfc
= mlx4_en_get_rxnfc
,
2091 .set_rxnfc
= mlx4_en_set_rxnfc
,
2092 .get_rxfh_indir_size
= mlx4_en_get_rxfh_indir_size
,
2093 .get_rxfh_key_size
= mlx4_en_get_rxfh_key_size
,
2094 .get_rxfh
= mlx4_en_get_rxfh
,
2095 .set_rxfh
= mlx4_en_set_rxfh
,
2096 .get_channels
= mlx4_en_get_channels
,
2097 .set_channels
= mlx4_en_set_channels
,
2098 .get_ts_info
= mlx4_en_get_ts_info
,
2099 .set_priv_flags
= mlx4_en_set_priv_flags
,
2100 .get_priv_flags
= mlx4_en_get_priv_flags
,
2101 .get_tunable
= mlx4_en_get_tunable
,
2102 .set_tunable
= mlx4_en_set_tunable
,
2103 .get_module_info
= mlx4_en_get_module_info
,
2104 .get_module_eeprom
= mlx4_en_get_module_eeprom