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 (i
= 0; i
< priv
->tx_ring_num
; i
++) {
56 priv
->tx_cq
[i
]->moder_cnt
= priv
->tx_frames
;
57 priv
->tx_cq
[i
]->moder_time
= priv
->tx_usecs
;
59 err
= mlx4_en_set_cq_moder(priv
, priv
->tx_cq
[i
]);
65 if (priv
->adaptive_rx_coal
)
68 for (i
= 0; i
< priv
->rx_ring_num
; i
++) {
69 priv
->rx_cq
[i
]->moder_cnt
= priv
->rx_frames
;
70 priv
->rx_cq
[i
]->moder_time
= priv
->rx_usecs
;
71 priv
->last_moder_time
[i
] = MLX4_EN_AUTO_CONF
;
73 err
= mlx4_en_set_cq_moder(priv
, priv
->rx_cq
[i
]);
83 mlx4_en_get_drvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*drvinfo
)
85 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
86 struct mlx4_en_dev
*mdev
= priv
->mdev
;
88 strlcpy(drvinfo
->driver
, DRV_NAME
, sizeof(drvinfo
->driver
));
89 strlcpy(drvinfo
->version
, DRV_VERSION
" (" DRV_RELDATE
")",
90 sizeof(drvinfo
->version
));
91 snprintf(drvinfo
->fw_version
, sizeof(drvinfo
->fw_version
),
93 (u16
) (mdev
->dev
->caps
.fw_ver
>> 32),
94 (u16
) ((mdev
->dev
->caps
.fw_ver
>> 16) & 0xffff),
95 (u16
) (mdev
->dev
->caps
.fw_ver
& 0xffff));
96 strlcpy(drvinfo
->bus_info
, pci_name(mdev
->dev
->persist
->pdev
),
97 sizeof(drvinfo
->bus_info
));
100 static const char mlx4_en_priv_flags
[][ETH_GSTRING_LEN
] = {
105 static const char main_strings
[][ETH_GSTRING_LEN
] = {
106 /* main statistics */
107 "rx_packets", "tx_packets", "rx_bytes", "tx_bytes", "rx_errors",
108 "tx_errors", "rx_dropped", "tx_dropped", "multicast", "collisions",
109 "rx_length_errors", "rx_over_errors", "rx_crc_errors",
110 "rx_frame_errors", "rx_fifo_errors", "rx_missed_errors",
111 "tx_aborted_errors", "tx_carrier_errors", "tx_fifo_errors",
112 "tx_heartbeat_errors", "tx_window_errors",
114 /* port statistics */
117 "queue_stopped", "wake_queue", "tx_timeout", "rx_alloc_failed",
118 "rx_csum_good", "rx_csum_none", "rx_csum_complete", "tx_chksum_offload",
126 /* priority flow control statistics rx */
127 "rx_pause_prio_0", "rx_pause_duration_prio_0",
128 "rx_pause_transition_prio_0",
129 "rx_pause_prio_1", "rx_pause_duration_prio_1",
130 "rx_pause_transition_prio_1",
131 "rx_pause_prio_2", "rx_pause_duration_prio_2",
132 "rx_pause_transition_prio_2",
133 "rx_pause_prio_3", "rx_pause_duration_prio_3",
134 "rx_pause_transition_prio_3",
135 "rx_pause_prio_4", "rx_pause_duration_prio_4",
136 "rx_pause_transition_prio_4",
137 "rx_pause_prio_5", "rx_pause_duration_prio_5",
138 "rx_pause_transition_prio_5",
139 "rx_pause_prio_6", "rx_pause_duration_prio_6",
140 "rx_pause_transition_prio_6",
141 "rx_pause_prio_7", "rx_pause_duration_prio_7",
142 "rx_pause_transition_prio_7",
144 /* flow control statistics rx */
145 "rx_pause", "rx_pause_duration", "rx_pause_transition",
147 /* priority flow control statistics tx */
148 "tx_pause_prio_0", "tx_pause_duration_prio_0",
149 "tx_pause_transition_prio_0",
150 "tx_pause_prio_1", "tx_pause_duration_prio_1",
151 "tx_pause_transition_prio_1",
152 "tx_pause_prio_2", "tx_pause_duration_prio_2",
153 "tx_pause_transition_prio_2",
154 "tx_pause_prio_3", "tx_pause_duration_prio_3",
155 "tx_pause_transition_prio_3",
156 "tx_pause_prio_4", "tx_pause_duration_prio_4",
157 "tx_pause_transition_prio_4",
158 "tx_pause_prio_5", "tx_pause_duration_prio_5",
159 "tx_pause_transition_prio_5",
160 "tx_pause_prio_6", "tx_pause_duration_prio_6",
161 "tx_pause_transition_prio_6",
162 "tx_pause_prio_7", "tx_pause_duration_prio_7",
163 "tx_pause_transition_prio_7",
165 /* flow control statistics tx */
166 "tx_pause", "tx_pause_duration", "tx_pause_transition",
168 /* packet statistics */
169 "rx_multicast_packets",
170 "rx_broadcast_packets",
172 "rx_in_range_length_error",
173 "rx_out_range_length_error",
174 "tx_multicast_packets",
175 "tx_broadcast_packets",
176 "rx_prio_0_packets", "rx_prio_0_bytes",
177 "rx_prio_1_packets", "rx_prio_1_bytes",
178 "rx_prio_2_packets", "rx_prio_2_bytes",
179 "rx_prio_3_packets", "rx_prio_3_bytes",
180 "rx_prio_4_packets", "rx_prio_4_bytes",
181 "rx_prio_5_packets", "rx_prio_5_bytes",
182 "rx_prio_6_packets", "rx_prio_6_bytes",
183 "rx_prio_7_packets", "rx_prio_7_bytes",
184 "rx_novlan_packets", "rx_novlan_bytes",
185 "tx_prio_0_packets", "tx_prio_0_bytes",
186 "tx_prio_1_packets", "tx_prio_1_bytes",
187 "tx_prio_2_packets", "tx_prio_2_bytes",
188 "tx_prio_3_packets", "tx_prio_3_bytes",
189 "tx_prio_4_packets", "tx_prio_4_bytes",
190 "tx_prio_5_packets", "tx_prio_5_bytes",
191 "tx_prio_6_packets", "tx_prio_6_bytes",
192 "tx_prio_7_packets", "tx_prio_7_bytes",
193 "tx_novlan_packets", "tx_novlan_bytes",
197 static const char mlx4_en_test_names
[][ETH_GSTRING_LEN
]= {
205 static u32
mlx4_en_get_msglevel(struct net_device
*dev
)
207 return ((struct mlx4_en_priv
*) netdev_priv(dev
))->msg_enable
;
210 static void mlx4_en_set_msglevel(struct net_device
*dev
, u32 val
)
212 ((struct mlx4_en_priv
*) netdev_priv(dev
))->msg_enable
= val
;
215 static void mlx4_en_get_wol(struct net_device
*netdev
,
216 struct ethtool_wolinfo
*wol
)
218 struct mlx4_en_priv
*priv
= netdev_priv(netdev
);
223 if ((priv
->port
< 1) || (priv
->port
> 2)) {
224 en_err(priv
, "Failed to get WoL information\n");
228 mask
= (priv
->port
== 1) ? MLX4_DEV_CAP_FLAG_WOL_PORT1
:
229 MLX4_DEV_CAP_FLAG_WOL_PORT2
;
231 if (!(priv
->mdev
->dev
->caps
.flags
& mask
)) {
237 err
= mlx4_wol_read(priv
->mdev
->dev
, &config
, priv
->port
);
239 en_err(priv
, "Failed to get WoL information\n");
243 if (config
& MLX4_EN_WOL_MAGIC
)
244 wol
->supported
= WAKE_MAGIC
;
248 if (config
& MLX4_EN_WOL_ENABLED
)
249 wol
->wolopts
= WAKE_MAGIC
;
254 static int mlx4_en_set_wol(struct net_device
*netdev
,
255 struct ethtool_wolinfo
*wol
)
257 struct mlx4_en_priv
*priv
= netdev_priv(netdev
);
262 if ((priv
->port
< 1) || (priv
->port
> 2))
265 mask
= (priv
->port
== 1) ? MLX4_DEV_CAP_FLAG_WOL_PORT1
:
266 MLX4_DEV_CAP_FLAG_WOL_PORT2
;
268 if (!(priv
->mdev
->dev
->caps
.flags
& mask
))
271 if (wol
->supported
& ~WAKE_MAGIC
)
274 err
= mlx4_wol_read(priv
->mdev
->dev
, &config
, priv
->port
);
276 en_err(priv
, "Failed to get WoL info, unable to modify\n");
280 if (wol
->wolopts
& WAKE_MAGIC
) {
281 config
|= MLX4_EN_WOL_DO_MODIFY
| MLX4_EN_WOL_ENABLED
|
284 config
&= ~(MLX4_EN_WOL_ENABLED
| MLX4_EN_WOL_MAGIC
);
285 config
|= MLX4_EN_WOL_DO_MODIFY
;
288 err
= mlx4_wol_write(priv
->mdev
->dev
, config
, priv
->port
);
290 en_err(priv
, "Failed to set WoL information\n");
295 struct bitmap_iterator
{
296 unsigned long *stats_bitmap
;
298 unsigned int iterator
;
299 bool advance_array
; /* if set, force no increments */
302 static inline void bitmap_iterator_init(struct bitmap_iterator
*h
,
303 unsigned long *stats_bitmap
,
307 h
->advance_array
= !bitmap_empty(stats_bitmap
, count
);
308 h
->count
= h
->advance_array
? bitmap_weight(stats_bitmap
, count
)
310 h
->stats_bitmap
= stats_bitmap
;
313 static inline int bitmap_iterator_test(struct bitmap_iterator
*h
)
315 return !h
->advance_array
? 1 : test_bit(h
->iterator
, h
->stats_bitmap
);
318 static inline int bitmap_iterator_inc(struct bitmap_iterator
*h
)
320 return h
->iterator
++;
323 static inline unsigned int
324 bitmap_iterator_count(struct bitmap_iterator
*h
)
329 static int mlx4_en_get_sset_count(struct net_device
*dev
, int sset
)
331 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
332 struct bitmap_iterator it
;
334 bitmap_iterator_init(&it
, priv
->stats_bitmap
.bitmap
, NUM_ALL_STATS
);
338 return bitmap_iterator_count(&it
) +
339 (priv
->tx_ring_num
* 2) +
340 (priv
->rx_ring_num
* 2);
342 return MLX4_EN_NUM_SELF_TEST
- !(priv
->mdev
->dev
->caps
.flags
343 & MLX4_DEV_CAP_FLAG_UC_LOOPBACK
) * 2;
344 case ETH_SS_PRIV_FLAGS
:
345 return ARRAY_SIZE(mlx4_en_priv_flags
);
351 static void mlx4_en_get_ethtool_stats(struct net_device
*dev
,
352 struct ethtool_stats
*stats
, uint64_t *data
)
354 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
357 struct bitmap_iterator it
;
359 bitmap_iterator_init(&it
, priv
->stats_bitmap
.bitmap
, NUM_ALL_STATS
);
361 spin_lock_bh(&priv
->stats_lock
);
363 for (i
= 0; i
< NUM_MAIN_STATS
; i
++, bitmap_iterator_inc(&it
))
364 if (bitmap_iterator_test(&it
))
365 data
[index
++] = ((unsigned long *)&priv
->stats
)[i
];
367 for (i
= 0; i
< NUM_PORT_STATS
; i
++, bitmap_iterator_inc(&it
))
368 if (bitmap_iterator_test(&it
))
369 data
[index
++] = ((unsigned long *)&priv
->port_stats
)[i
];
371 for (i
= 0; i
< NUM_PF_STATS
; i
++, bitmap_iterator_inc(&it
))
372 if (bitmap_iterator_test(&it
))
374 ((unsigned long *)&priv
->pf_stats
)[i
];
376 for (i
= 0; i
< NUM_FLOW_PRIORITY_STATS_RX
;
377 i
++, bitmap_iterator_inc(&it
))
378 if (bitmap_iterator_test(&it
))
380 ((u64
*)&priv
->rx_priority_flowstats
)[i
];
382 for (i
= 0; i
< NUM_FLOW_STATS_RX
; i
++, bitmap_iterator_inc(&it
))
383 if (bitmap_iterator_test(&it
))
384 data
[index
++] = ((u64
*)&priv
->rx_flowstats
)[i
];
386 for (i
= 0; i
< NUM_FLOW_PRIORITY_STATS_TX
;
387 i
++, bitmap_iterator_inc(&it
))
388 if (bitmap_iterator_test(&it
))
390 ((u64
*)&priv
->tx_priority_flowstats
)[i
];
392 for (i
= 0; i
< NUM_FLOW_STATS_TX
; i
++, bitmap_iterator_inc(&it
))
393 if (bitmap_iterator_test(&it
))
394 data
[index
++] = ((u64
*)&priv
->tx_flowstats
)[i
];
396 for (i
= 0; i
< NUM_PKT_STATS
; i
++, bitmap_iterator_inc(&it
))
397 if (bitmap_iterator_test(&it
))
398 data
[index
++] = ((unsigned long *)&priv
->pkstats
)[i
];
400 for (i
= 0; i
< priv
->tx_ring_num
; i
++) {
401 data
[index
++] = priv
->tx_ring
[i
]->packets
;
402 data
[index
++] = priv
->tx_ring
[i
]->bytes
;
404 for (i
= 0; i
< priv
->rx_ring_num
; i
++) {
405 data
[index
++] = priv
->rx_ring
[i
]->packets
;
406 data
[index
++] = priv
->rx_ring
[i
]->bytes
;
408 spin_unlock_bh(&priv
->stats_lock
);
412 static void mlx4_en_self_test(struct net_device
*dev
,
413 struct ethtool_test
*etest
, u64
*buf
)
415 mlx4_en_ex_selftest(dev
, &etest
->flags
, buf
);
418 static void mlx4_en_get_strings(struct net_device
*dev
,
419 uint32_t stringset
, uint8_t *data
)
421 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
424 struct bitmap_iterator it
;
426 bitmap_iterator_init(&it
, priv
->stats_bitmap
.bitmap
, NUM_ALL_STATS
);
430 for (i
= 0; i
< MLX4_EN_NUM_SELF_TEST
- 2; i
++)
431 strcpy(data
+ i
* ETH_GSTRING_LEN
, mlx4_en_test_names
[i
]);
432 if (priv
->mdev
->dev
->caps
.flags
& MLX4_DEV_CAP_FLAG_UC_LOOPBACK
)
433 for (; i
< MLX4_EN_NUM_SELF_TEST
; i
++)
434 strcpy(data
+ i
* ETH_GSTRING_LEN
, mlx4_en_test_names
[i
]);
438 /* Add main counters */
439 for (i
= 0; i
< NUM_MAIN_STATS
; i
++, strings
++,
440 bitmap_iterator_inc(&it
))
441 if (bitmap_iterator_test(&it
))
442 strcpy(data
+ (index
++) * ETH_GSTRING_LEN
,
443 main_strings
[strings
]);
445 for (i
= 0; i
< NUM_PORT_STATS
; i
++, strings
++,
446 bitmap_iterator_inc(&it
))
447 if (bitmap_iterator_test(&it
))
448 strcpy(data
+ (index
++) * ETH_GSTRING_LEN
,
449 main_strings
[strings
]);
451 for (i
= 0; i
< NUM_PF_STATS
; i
++, strings
++,
452 bitmap_iterator_inc(&it
))
453 if (bitmap_iterator_test(&it
))
454 strcpy(data
+ (index
++) * ETH_GSTRING_LEN
,
455 main_strings
[strings
]);
457 for (i
= 0; i
< NUM_FLOW_STATS
; i
++, strings
++,
458 bitmap_iterator_inc(&it
))
459 if (bitmap_iterator_test(&it
))
460 strcpy(data
+ (index
++) * ETH_GSTRING_LEN
,
461 main_strings
[strings
]);
463 for (i
= 0; i
< NUM_PKT_STATS
; i
++, strings
++,
464 bitmap_iterator_inc(&it
))
465 if (bitmap_iterator_test(&it
))
466 strcpy(data
+ (index
++) * ETH_GSTRING_LEN
,
467 main_strings
[strings
]);
469 for (i
= 0; i
< priv
->tx_ring_num
; i
++) {
470 sprintf(data
+ (index
++) * ETH_GSTRING_LEN
,
472 sprintf(data
+ (index
++) * ETH_GSTRING_LEN
,
475 for (i
= 0; i
< priv
->rx_ring_num
; i
++) {
476 sprintf(data
+ (index
++) * ETH_GSTRING_LEN
,
478 sprintf(data
+ (index
++) * ETH_GSTRING_LEN
,
482 case ETH_SS_PRIV_FLAGS
:
483 for (i
= 0; i
< ARRAY_SIZE(mlx4_en_priv_flags
); i
++)
484 strcpy(data
+ i
* ETH_GSTRING_LEN
,
485 mlx4_en_priv_flags
[i
]);
491 static u32
mlx4_en_autoneg_get(struct net_device
*dev
)
493 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
494 struct mlx4_en_dev
*mdev
= priv
->mdev
;
495 u32 autoneg
= AUTONEG_DISABLE
;
497 if ((mdev
->dev
->caps
.flags2
& MLX4_DEV_CAP_FLAG2_ETH_BACKPL_AN_REP
) &&
498 (priv
->port_state
.flags
& MLX4_EN_PORT_ANE
))
499 autoneg
= AUTONEG_ENABLE
;
504 static void ptys2ethtool_update_supported_port(unsigned long *mask
,
505 struct mlx4_ptys_reg
*ptys_reg
)
507 u32 eth_proto
= be32_to_cpu(ptys_reg
->eth_proto_cap
);
509 if (eth_proto
& (MLX4_PROT_MASK(MLX4_10GBASE_T
)
510 | MLX4_PROT_MASK(MLX4_1000BASE_T
)
511 | MLX4_PROT_MASK(MLX4_100BASE_TX
))) {
512 __set_bit(ETHTOOL_LINK_MODE_TP_BIT
, mask
);
513 } else if (eth_proto
& (MLX4_PROT_MASK(MLX4_10GBASE_CR
)
514 | MLX4_PROT_MASK(MLX4_10GBASE_SR
)
515 | MLX4_PROT_MASK(MLX4_56GBASE_SR4
)
516 | MLX4_PROT_MASK(MLX4_40GBASE_CR4
)
517 | MLX4_PROT_MASK(MLX4_40GBASE_SR4
)
518 | MLX4_PROT_MASK(MLX4_1000BASE_CX_SGMII
))) {
519 __set_bit(ETHTOOL_LINK_MODE_FIBRE_BIT
, mask
);
520 } else if (eth_proto
& (MLX4_PROT_MASK(MLX4_56GBASE_KR4
)
521 | MLX4_PROT_MASK(MLX4_40GBASE_KR4
)
522 | MLX4_PROT_MASK(MLX4_20GBASE_KR2
)
523 | MLX4_PROT_MASK(MLX4_10GBASE_KR
)
524 | MLX4_PROT_MASK(MLX4_10GBASE_KX4
)
525 | MLX4_PROT_MASK(MLX4_1000BASE_KX
))) {
526 __set_bit(ETHTOOL_LINK_MODE_Backplane_BIT
, mask
);
530 static u32
ptys_get_active_port(struct mlx4_ptys_reg
*ptys_reg
)
532 u32 eth_proto
= be32_to_cpu(ptys_reg
->eth_proto_oper
);
534 if (!eth_proto
) /* link down */
535 eth_proto
= be32_to_cpu(ptys_reg
->eth_proto_cap
);
537 if (eth_proto
& (MLX4_PROT_MASK(MLX4_10GBASE_T
)
538 | MLX4_PROT_MASK(MLX4_1000BASE_T
)
539 | MLX4_PROT_MASK(MLX4_100BASE_TX
))) {
543 if (eth_proto
& (MLX4_PROT_MASK(MLX4_10GBASE_SR
)
544 | MLX4_PROT_MASK(MLX4_56GBASE_SR4
)
545 | MLX4_PROT_MASK(MLX4_40GBASE_SR4
)
546 | MLX4_PROT_MASK(MLX4_1000BASE_CX_SGMII
))) {
550 if (eth_proto
& (MLX4_PROT_MASK(MLX4_10GBASE_CR
)
551 | MLX4_PROT_MASK(MLX4_56GBASE_CR4
)
552 | MLX4_PROT_MASK(MLX4_40GBASE_CR4
))) {
556 if (eth_proto
& (MLX4_PROT_MASK(MLX4_56GBASE_KR4
)
557 | MLX4_PROT_MASK(MLX4_40GBASE_KR4
)
558 | MLX4_PROT_MASK(MLX4_20GBASE_KR2
)
559 | MLX4_PROT_MASK(MLX4_10GBASE_KR
)
560 | MLX4_PROT_MASK(MLX4_10GBASE_KX4
)
561 | MLX4_PROT_MASK(MLX4_1000BASE_KX
))) {
567 #define MLX4_LINK_MODES_SZ \
568 (FIELD_SIZEOF(struct mlx4_ptys_reg, eth_proto_cap) * 8)
570 enum ethtool_report
{
575 struct ptys2ethtool_config
{
576 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported
);
577 __ETHTOOL_DECLARE_LINK_MODE_MASK(advertised
);
581 static unsigned long *ptys2ethtool_link_mode(struct ptys2ethtool_config
*cfg
,
582 enum ethtool_report report
)
586 return cfg
->supported
;
588 return cfg
->advertised
;
593 #define MLX4_BUILD_PTYS2ETHTOOL_CONFIG(reg_, speed_, ...) \
595 struct ptys2ethtool_config *cfg; \
596 const unsigned int modes[] = { __VA_ARGS__ }; \
598 cfg = &ptys2ethtool_map[reg_]; \
599 cfg->speed = speed_; \
600 bitmap_zero(cfg->supported, \
601 __ETHTOOL_LINK_MODE_MASK_NBITS); \
602 bitmap_zero(cfg->advertised, \
603 __ETHTOOL_LINK_MODE_MASK_NBITS); \
604 for (i = 0 ; i < ARRAY_SIZE(modes) ; ++i) { \
605 __set_bit(modes[i], cfg->supported); \
606 __set_bit(modes[i], cfg->advertised); \
610 /* Translates mlx4 link mode to equivalent ethtool Link modes/speed */
611 static struct ptys2ethtool_config ptys2ethtool_map
[MLX4_LINK_MODES_SZ
];
613 void __init
mlx4_en_init_ptys2ethtool_map(void)
615 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_100BASE_TX
, SPEED_100
,
616 ETHTOOL_LINK_MODE_100baseT_Full_BIT
);
617 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_1000BASE_T
, SPEED_1000
,
618 ETHTOOL_LINK_MODE_1000baseT_Full_BIT
);
619 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_1000BASE_CX_SGMII
, SPEED_1000
,
620 ETHTOOL_LINK_MODE_1000baseKX_Full_BIT
);
621 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_1000BASE_KX
, SPEED_1000
,
622 ETHTOOL_LINK_MODE_1000baseKX_Full_BIT
);
623 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_T
, SPEED_10000
,
624 ETHTOOL_LINK_MODE_10000baseT_Full_BIT
);
625 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_CX4
, SPEED_10000
,
626 ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT
);
627 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_KX4
, SPEED_10000
,
628 ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT
);
629 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_KR
, SPEED_10000
,
630 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT
);
631 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_CR
, SPEED_10000
,
632 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT
);
633 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_SR
, SPEED_10000
,
634 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT
);
635 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_20GBASE_KR2
, SPEED_20000
,
636 ETHTOOL_LINK_MODE_20000baseMLD2_Full_BIT
,
637 ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT
);
638 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_40GBASE_CR4
, SPEED_40000
,
639 ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT
);
640 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_40GBASE_KR4
, SPEED_40000
,
641 ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT
);
642 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_40GBASE_SR4
, SPEED_40000
,
643 ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT
);
644 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_56GBASE_KR4
, SPEED_56000
,
645 ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT
);
646 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_56GBASE_CR4
, SPEED_56000
,
647 ETHTOOL_LINK_MODE_56000baseCR4_Full_BIT
);
648 MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_56GBASE_SR4
, SPEED_56000
,
649 ETHTOOL_LINK_MODE_56000baseSR4_Full_BIT
);
652 static void ptys2ethtool_update_link_modes(unsigned long *link_modes
,
654 enum ethtool_report report
)
657 for (i
= 0; i
< MLX4_LINK_MODES_SZ
; i
++) {
658 if (eth_proto
& MLX4_PROT_MASK(i
))
659 bitmap_or(link_modes
, link_modes
,
660 ptys2ethtool_link_mode(&ptys2ethtool_map
[i
],
662 __ETHTOOL_LINK_MODE_MASK_NBITS
);
666 static u32
ethtool2ptys_link_modes(const unsigned long *link_modes
,
667 enum ethtool_report report
)
672 for (i
= 0; i
< MLX4_LINK_MODES_SZ
; i
++) {
673 if (bitmap_intersects(
674 ptys2ethtool_link_mode(&ptys2ethtool_map
[i
],
677 __ETHTOOL_LINK_MODE_MASK_NBITS
))
678 ptys_modes
|= 1 << i
;
683 /* Convert actual speed (SPEED_XXX) to ptys link modes */
684 static u32
speed2ptys_link_modes(u32 speed
)
689 for (i
= 0; i
< MLX4_LINK_MODES_SZ
; i
++) {
690 if (ptys2ethtool_map
[i
].speed
== speed
)
691 ptys_modes
|= 1 << i
;
697 ethtool_get_ptys_link_ksettings(struct net_device
*dev
,
698 struct ethtool_link_ksettings
*link_ksettings
)
700 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
701 struct mlx4_ptys_reg ptys_reg
;
705 memset(&ptys_reg
, 0, sizeof(ptys_reg
));
706 ptys_reg
.local_port
= priv
->port
;
707 ptys_reg
.proto_mask
= MLX4_PTYS_EN
;
708 ret
= mlx4_ACCESS_PTYS_REG(priv
->mdev
->dev
,
709 MLX4_ACCESS_REG_QUERY
, &ptys_reg
);
711 en_warn(priv
, "Failed to run mlx4_ACCESS_PTYS_REG status(%x)",
715 en_dbg(DRV
, priv
, "ptys_reg.proto_mask %x\n",
716 ptys_reg
.proto_mask
);
717 en_dbg(DRV
, priv
, "ptys_reg.eth_proto_cap %x\n",
718 be32_to_cpu(ptys_reg
.eth_proto_cap
));
719 en_dbg(DRV
, priv
, "ptys_reg.eth_proto_admin %x\n",
720 be32_to_cpu(ptys_reg
.eth_proto_admin
));
721 en_dbg(DRV
, priv
, "ptys_reg.eth_proto_oper %x\n",
722 be32_to_cpu(ptys_reg
.eth_proto_oper
));
723 en_dbg(DRV
, priv
, "ptys_reg.eth_proto_lp_adv %x\n",
724 be32_to_cpu(ptys_reg
.eth_proto_lp_adv
));
726 /* reset supported/advertising masks */
727 ethtool_link_ksettings_zero_link_mode(link_ksettings
, supported
);
728 ethtool_link_ksettings_zero_link_mode(link_ksettings
, advertising
);
730 ptys2ethtool_update_supported_port(link_ksettings
->link_modes
.supported
,
733 eth_proto
= be32_to_cpu(ptys_reg
.eth_proto_cap
);
734 ptys2ethtool_update_link_modes(link_ksettings
->link_modes
.supported
,
735 eth_proto
, SUPPORTED
);
737 eth_proto
= be32_to_cpu(ptys_reg
.eth_proto_admin
);
738 ptys2ethtool_update_link_modes(link_ksettings
->link_modes
.advertising
,
739 eth_proto
, ADVERTISED
);
741 ethtool_link_ksettings_add_link_mode(link_ksettings
, supported
,
743 ethtool_link_ksettings_add_link_mode(link_ksettings
, supported
,
746 if (priv
->prof
->tx_pause
)
747 ethtool_link_ksettings_add_link_mode(link_ksettings
,
749 if (priv
->prof
->tx_pause
^ priv
->prof
->rx_pause
)
750 ethtool_link_ksettings_add_link_mode(link_ksettings
,
751 advertising
, Asym_Pause
);
753 link_ksettings
->base
.port
= ptys_get_active_port(&ptys_reg
);
755 if (mlx4_en_autoneg_get(dev
)) {
756 ethtool_link_ksettings_add_link_mode(link_ksettings
,
758 ethtool_link_ksettings_add_link_mode(link_ksettings
,
759 advertising
, Autoneg
);
762 link_ksettings
->base
.autoneg
763 = (priv
->port_state
.flags
& MLX4_EN_PORT_ANC
) ?
764 AUTONEG_ENABLE
: AUTONEG_DISABLE
;
766 eth_proto
= be32_to_cpu(ptys_reg
.eth_proto_lp_adv
);
768 ethtool_link_ksettings_zero_link_mode(link_ksettings
, lp_advertising
);
769 ptys2ethtool_update_link_modes(
770 link_ksettings
->link_modes
.lp_advertising
,
771 eth_proto
, ADVERTISED
);
772 if (priv
->port_state
.flags
& MLX4_EN_PORT_ANC
)
773 ethtool_link_ksettings_add_link_mode(link_ksettings
,
774 lp_advertising
, Autoneg
);
776 link_ksettings
->base
.phy_address
= 0;
777 link_ksettings
->base
.mdio_support
= 0;
778 link_ksettings
->base
.eth_tp_mdix
= ETH_TP_MDI_INVALID
;
779 link_ksettings
->base
.eth_tp_mdix_ctrl
= ETH_TP_MDI_AUTO
;
785 ethtool_get_default_link_ksettings(
786 struct net_device
*dev
, struct ethtool_link_ksettings
*link_ksettings
)
788 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
791 link_ksettings
->base
.autoneg
= AUTONEG_DISABLE
;
793 ethtool_link_ksettings_zero_link_mode(link_ksettings
, supported
);
794 ethtool_link_ksettings_add_link_mode(link_ksettings
, supported
,
797 ethtool_link_ksettings_zero_link_mode(link_ksettings
, advertising
);
798 ethtool_link_ksettings_add_link_mode(link_ksettings
, advertising
,
801 trans_type
= priv
->port_state
.transceiver
;
802 if (trans_type
> 0 && trans_type
<= 0xC) {
803 link_ksettings
->base
.port
= PORT_FIBRE
;
804 ethtool_link_ksettings_add_link_mode(link_ksettings
,
806 ethtool_link_ksettings_add_link_mode(link_ksettings
,
808 } else if (trans_type
== 0x80 || trans_type
== 0) {
809 link_ksettings
->base
.port
= PORT_TP
;
810 ethtool_link_ksettings_add_link_mode(link_ksettings
,
812 ethtool_link_ksettings_add_link_mode(link_ksettings
,
815 link_ksettings
->base
.port
= -1;
820 mlx4_en_get_link_ksettings(struct net_device
*dev
,
821 struct ethtool_link_ksettings
*link_ksettings
)
823 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
826 if (mlx4_en_QUERY_PORT(priv
->mdev
, priv
->port
))
829 en_dbg(DRV
, priv
, "query port state.flags ANC(%x) ANE(%x)\n",
830 priv
->port_state
.flags
& MLX4_EN_PORT_ANC
,
831 priv
->port_state
.flags
& MLX4_EN_PORT_ANE
);
833 if (priv
->mdev
->dev
->caps
.flags2
& MLX4_DEV_CAP_FLAG2_ETH_PROT_CTRL
)
834 ret
= ethtool_get_ptys_link_ksettings(dev
, link_ksettings
);
835 if (ret
) /* ETH PROT CRTL is not supported or PTYS CMD failed */
836 ethtool_get_default_link_ksettings(dev
, link_ksettings
);
838 if (netif_carrier_ok(dev
)) {
839 link_ksettings
->base
.speed
= priv
->port_state
.link_speed
;
840 link_ksettings
->base
.duplex
= DUPLEX_FULL
;
842 link_ksettings
->base
.speed
= SPEED_UNKNOWN
;
843 link_ksettings
->base
.duplex
= DUPLEX_UNKNOWN
;
848 /* Calculate PTYS admin according ethtool speed (SPEED_XXX) */
849 static __be32
speed_set_ptys_admin(struct mlx4_en_priv
*priv
, u32 speed
,
852 __be32 proto_admin
= 0;
854 if (!speed
) { /* Speed = 0 ==> Reset Link modes */
855 proto_admin
= proto_cap
;
856 en_info(priv
, "Speed was set to 0, Reset advertised Link Modes to default (%x)\n",
857 be32_to_cpu(proto_cap
));
859 u32 ptys_link_modes
= speed2ptys_link_modes(speed
);
861 proto_admin
= cpu_to_be32(ptys_link_modes
) & proto_cap
;
862 en_info(priv
, "Setting Speed to %d\n", speed
);
868 mlx4_en_set_link_ksettings(struct net_device
*dev
,
869 const struct ethtool_link_ksettings
*link_ksettings
)
871 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
872 struct mlx4_ptys_reg ptys_reg
;
876 u32 ptys_adv
= ethtool2ptys_link_modes(
877 link_ksettings
->link_modes
.advertising
, ADVERTISED
);
878 const int speed
= link_ksettings
->base
.speed
;
881 "Set Speed=%d adv={%*pbl} autoneg=%d duplex=%d\n",
882 speed
, __ETHTOOL_LINK_MODE_MASK_NBITS
,
883 link_ksettings
->link_modes
.advertising
,
884 link_ksettings
->base
.autoneg
,
885 link_ksettings
->base
.duplex
);
887 if (!(priv
->mdev
->dev
->caps
.flags2
&
888 MLX4_DEV_CAP_FLAG2_ETH_PROT_CTRL
) ||
889 (link_ksettings
->base
.duplex
== DUPLEX_HALF
))
892 memset(&ptys_reg
, 0, sizeof(ptys_reg
));
893 ptys_reg
.local_port
= priv
->port
;
894 ptys_reg
.proto_mask
= MLX4_PTYS_EN
;
895 ret
= mlx4_ACCESS_PTYS_REG(priv
->mdev
->dev
,
896 MLX4_ACCESS_REG_QUERY
, &ptys_reg
);
898 en_warn(priv
, "Failed to QUERY mlx4_ACCESS_PTYS_REG status(%x)\n",
903 proto_admin
= link_ksettings
->base
.autoneg
== AUTONEG_ENABLE
?
904 cpu_to_be32(ptys_adv
) :
905 speed_set_ptys_admin(priv
, speed
,
906 ptys_reg
.eth_proto_cap
);
908 proto_admin
&= ptys_reg
.eth_proto_cap
;
910 en_warn(priv
, "Not supported link mode(s) requested, check supported link modes.\n");
911 return -EINVAL
; /* nothing to change due to bad input */
914 if (proto_admin
== ptys_reg
.eth_proto_admin
)
915 return 0; /* Nothing to change */
917 en_dbg(DRV
, priv
, "mlx4_ACCESS_PTYS_REG SET: ptys_reg.eth_proto_admin = 0x%x\n",
918 be32_to_cpu(proto_admin
));
920 ptys_reg
.eth_proto_admin
= proto_admin
;
921 ret
= mlx4_ACCESS_PTYS_REG(priv
->mdev
->dev
, MLX4_ACCESS_REG_WRITE
,
924 en_warn(priv
, "Failed to write mlx4_ACCESS_PTYS_REG eth_proto_admin(0x%x) status(0x%x)",
925 be32_to_cpu(ptys_reg
.eth_proto_admin
), ret
);
929 mutex_lock(&priv
->mdev
->state_lock
);
931 en_warn(priv
, "Port link mode changed, restarting port...\n");
932 mlx4_en_stop_port(dev
, 1);
933 if (mlx4_en_start_port(dev
))
934 en_err(priv
, "Failed restarting port %d\n", priv
->port
);
936 mutex_unlock(&priv
->mdev
->state_lock
);
940 static int mlx4_en_get_coalesce(struct net_device
*dev
,
941 struct ethtool_coalesce
*coal
)
943 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
945 coal
->tx_coalesce_usecs
= priv
->tx_usecs
;
946 coal
->tx_max_coalesced_frames
= priv
->tx_frames
;
947 coal
->tx_max_coalesced_frames_irq
= priv
->tx_work_limit
;
949 coal
->rx_coalesce_usecs
= priv
->rx_usecs
;
950 coal
->rx_max_coalesced_frames
= priv
->rx_frames
;
952 coal
->pkt_rate_low
= priv
->pkt_rate_low
;
953 coal
->rx_coalesce_usecs_low
= priv
->rx_usecs_low
;
954 coal
->pkt_rate_high
= priv
->pkt_rate_high
;
955 coal
->rx_coalesce_usecs_high
= priv
->rx_usecs_high
;
956 coal
->rate_sample_interval
= priv
->sample_interval
;
957 coal
->use_adaptive_rx_coalesce
= priv
->adaptive_rx_coal
;
962 static int mlx4_en_set_coalesce(struct net_device
*dev
,
963 struct ethtool_coalesce
*coal
)
965 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
967 if (!coal
->tx_max_coalesced_frames_irq
)
970 priv
->rx_frames
= (coal
->rx_max_coalesced_frames
==
972 MLX4_EN_RX_COAL_TARGET
:
973 coal
->rx_max_coalesced_frames
;
974 priv
->rx_usecs
= (coal
->rx_coalesce_usecs
==
976 MLX4_EN_RX_COAL_TIME
:
977 coal
->rx_coalesce_usecs
;
979 /* Setting TX coalescing parameters */
980 if (coal
->tx_coalesce_usecs
!= priv
->tx_usecs
||
981 coal
->tx_max_coalesced_frames
!= priv
->tx_frames
) {
982 priv
->tx_usecs
= coal
->tx_coalesce_usecs
;
983 priv
->tx_frames
= coal
->tx_max_coalesced_frames
;
986 /* Set adaptive coalescing params */
987 priv
->pkt_rate_low
= coal
->pkt_rate_low
;
988 priv
->rx_usecs_low
= coal
->rx_coalesce_usecs_low
;
989 priv
->pkt_rate_high
= coal
->pkt_rate_high
;
990 priv
->rx_usecs_high
= coal
->rx_coalesce_usecs_high
;
991 priv
->sample_interval
= coal
->rate_sample_interval
;
992 priv
->adaptive_rx_coal
= coal
->use_adaptive_rx_coalesce
;
993 priv
->tx_work_limit
= coal
->tx_max_coalesced_frames_irq
;
995 return mlx4_en_moderation_update(priv
);
998 static int mlx4_en_set_pauseparam(struct net_device
*dev
,
999 struct ethtool_pauseparam
*pause
)
1001 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1002 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1008 priv
->prof
->tx_pause
= pause
->tx_pause
!= 0;
1009 priv
->prof
->rx_pause
= pause
->rx_pause
!= 0;
1010 err
= mlx4_SET_PORT_general(mdev
->dev
, priv
->port
,
1011 priv
->rx_skb_size
+ ETH_FCS_LEN
,
1012 priv
->prof
->tx_pause
,
1014 priv
->prof
->rx_pause
,
1015 priv
->prof
->rx_ppp
);
1017 en_err(priv
, "Failed setting pause params\n");
1019 mlx4_en_update_pfc_stats_bitmap(mdev
->dev
, &priv
->stats_bitmap
,
1021 priv
->prof
->rx_pause
,
1023 priv
->prof
->tx_pause
);
1028 static void mlx4_en_get_pauseparam(struct net_device
*dev
,
1029 struct ethtool_pauseparam
*pause
)
1031 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1033 pause
->tx_pause
= priv
->prof
->tx_pause
;
1034 pause
->rx_pause
= priv
->prof
->rx_pause
;
1037 static int mlx4_en_set_ringparam(struct net_device
*dev
,
1038 struct ethtool_ringparam
*param
)
1040 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1041 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1042 u32 rx_size
, tx_size
;
1046 if (param
->rx_jumbo_pending
|| param
->rx_mini_pending
)
1049 rx_size
= roundup_pow_of_two(param
->rx_pending
);
1050 rx_size
= max_t(u32
, rx_size
, MLX4_EN_MIN_RX_SIZE
);
1051 rx_size
= min_t(u32
, rx_size
, MLX4_EN_MAX_RX_SIZE
);
1052 tx_size
= roundup_pow_of_two(param
->tx_pending
);
1053 tx_size
= max_t(u32
, tx_size
, MLX4_EN_MIN_TX_SIZE
);
1054 tx_size
= min_t(u32
, tx_size
, MLX4_EN_MAX_TX_SIZE
);
1056 if (rx_size
== (priv
->port_up
? priv
->rx_ring
[0]->actual_size
:
1057 priv
->rx_ring
[0]->size
) &&
1058 tx_size
== priv
->tx_ring
[0]->size
)
1061 mutex_lock(&mdev
->state_lock
);
1062 if (priv
->port_up
) {
1064 mlx4_en_stop_port(dev
, 1);
1067 mlx4_en_free_resources(priv
);
1069 priv
->prof
->tx_ring_size
= tx_size
;
1070 priv
->prof
->rx_ring_size
= rx_size
;
1072 err
= mlx4_en_alloc_resources(priv
);
1074 en_err(priv
, "Failed reallocating port resources\n");
1078 err
= mlx4_en_start_port(dev
);
1080 en_err(priv
, "Failed starting port\n");
1083 err
= mlx4_en_moderation_update(priv
);
1086 mutex_unlock(&mdev
->state_lock
);
1090 static void mlx4_en_get_ringparam(struct net_device
*dev
,
1091 struct ethtool_ringparam
*param
)
1093 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1095 memset(param
, 0, sizeof(*param
));
1096 param
->rx_max_pending
= MLX4_EN_MAX_RX_SIZE
;
1097 param
->tx_max_pending
= MLX4_EN_MAX_TX_SIZE
;
1098 param
->rx_pending
= priv
->port_up
?
1099 priv
->rx_ring
[0]->actual_size
: priv
->rx_ring
[0]->size
;
1100 param
->tx_pending
= priv
->tx_ring
[0]->size
;
1103 static u32
mlx4_en_get_rxfh_indir_size(struct net_device
*dev
)
1105 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1107 return priv
->rx_ring_num
;
1110 static u32
mlx4_en_get_rxfh_key_size(struct net_device
*netdev
)
1112 return MLX4_EN_RSS_KEY_SIZE
;
1115 static int mlx4_en_check_rxfh_func(struct net_device
*dev
, u8 hfunc
)
1117 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1119 /* check if requested function is supported by the device */
1120 if (hfunc
== ETH_RSS_HASH_TOP
) {
1121 if (!(priv
->mdev
->dev
->caps
.flags2
& MLX4_DEV_CAP_FLAG2_RSS_TOP
))
1123 if (!(dev
->features
& NETIF_F_RXHASH
))
1124 en_warn(priv
, "Toeplitz hash function should be used in conjunction with RX hashing for optimal performance\n");
1126 } else if (hfunc
== ETH_RSS_HASH_XOR
) {
1127 if (!(priv
->mdev
->dev
->caps
.flags2
& MLX4_DEV_CAP_FLAG2_RSS_XOR
))
1129 if (dev
->features
& NETIF_F_RXHASH
)
1130 en_warn(priv
, "Enabling both XOR Hash function and RX Hashing can limit RPS functionality\n");
1137 static int mlx4_en_get_rxfh(struct net_device
*dev
, u32
*ring_index
, u8
*key
,
1140 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1141 struct mlx4_en_rss_map
*rss_map
= &priv
->rss_map
;
1143 size_t n
= priv
->rx_ring_num
;
1146 rss_rings
= priv
->prof
->rss_rings
?: priv
->rx_ring_num
;
1147 rss_rings
= 1 << ilog2(rss_rings
);
1152 ring_index
[n
] = rss_map
->qps
[n
% rss_rings
].qpn
-
1156 memcpy(key
, priv
->rss_key
, MLX4_EN_RSS_KEY_SIZE
);
1158 *hfunc
= priv
->rss_hash_fn
;
1162 static int mlx4_en_set_rxfh(struct net_device
*dev
, const u32
*ring_index
,
1163 const u8
*key
, const u8 hfunc
)
1165 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1166 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1172 /* Calculate RSS table size and make sure flows are spread evenly
1175 for (i
= 0; i
< priv
->rx_ring_num
; i
++) {
1178 if (i
> 0 && !ring_index
[i
] && !rss_rings
)
1181 if (ring_index
[i
] != (i
% (rss_rings
?: priv
->rx_ring_num
)))
1186 rss_rings
= priv
->rx_ring_num
;
1188 /* RSS table size must be an order of 2 */
1189 if (!is_power_of_2(rss_rings
))
1192 if (hfunc
!= ETH_RSS_HASH_NO_CHANGE
) {
1193 err
= mlx4_en_check_rxfh_func(dev
, hfunc
);
1198 mutex_lock(&mdev
->state_lock
);
1199 if (priv
->port_up
) {
1201 mlx4_en_stop_port(dev
, 1);
1205 priv
->prof
->rss_rings
= rss_rings
;
1207 memcpy(priv
->rss_key
, key
, MLX4_EN_RSS_KEY_SIZE
);
1208 if (hfunc
!= ETH_RSS_HASH_NO_CHANGE
)
1209 priv
->rss_hash_fn
= hfunc
;
1212 err
= mlx4_en_start_port(dev
);
1214 en_err(priv
, "Failed starting port\n");
1217 mutex_unlock(&mdev
->state_lock
);
1221 #define all_zeros_or_all_ones(field) \
1222 ((field) == 0 || (field) == (__force typeof(field))-1)
1224 static int mlx4_en_validate_flow(struct net_device
*dev
,
1225 struct ethtool_rxnfc
*cmd
)
1227 struct ethtool_usrip4_spec
*l3_mask
;
1228 struct ethtool_tcpip4_spec
*l4_mask
;
1229 struct ethhdr
*eth_mask
;
1231 if (cmd
->fs
.location
>= MAX_NUM_OF_FS_RULES
)
1234 if (cmd
->fs
.flow_type
& FLOW_MAC_EXT
) {
1235 /* dest mac mask must be ff:ff:ff:ff:ff:ff */
1236 if (!is_broadcast_ether_addr(cmd
->fs
.m_ext
.h_dest
))
1240 switch (cmd
->fs
.flow_type
& ~(FLOW_EXT
| FLOW_MAC_EXT
)) {
1243 if (cmd
->fs
.m_u
.tcp_ip4_spec
.tos
)
1245 l4_mask
= &cmd
->fs
.m_u
.tcp_ip4_spec
;
1246 /* don't allow mask which isn't all 0 or 1 */
1247 if (!all_zeros_or_all_ones(l4_mask
->ip4src
) ||
1248 !all_zeros_or_all_ones(l4_mask
->ip4dst
) ||
1249 !all_zeros_or_all_ones(l4_mask
->psrc
) ||
1250 !all_zeros_or_all_ones(l4_mask
->pdst
))
1254 l3_mask
= &cmd
->fs
.m_u
.usr_ip4_spec
;
1255 if (l3_mask
->l4_4_bytes
|| l3_mask
->tos
|| l3_mask
->proto
||
1256 cmd
->fs
.h_u
.usr_ip4_spec
.ip_ver
!= ETH_RX_NFC_IP4
||
1257 (!l3_mask
->ip4src
&& !l3_mask
->ip4dst
) ||
1258 !all_zeros_or_all_ones(l3_mask
->ip4src
) ||
1259 !all_zeros_or_all_ones(l3_mask
->ip4dst
))
1263 eth_mask
= &cmd
->fs
.m_u
.ether_spec
;
1264 /* source mac mask must not be set */
1265 if (!is_zero_ether_addr(eth_mask
->h_source
))
1268 /* dest mac mask must be ff:ff:ff:ff:ff:ff */
1269 if (!is_broadcast_ether_addr(eth_mask
->h_dest
))
1272 if (!all_zeros_or_all_ones(eth_mask
->h_proto
))
1279 if ((cmd
->fs
.flow_type
& FLOW_EXT
)) {
1280 if (cmd
->fs
.m_ext
.vlan_etype
||
1281 !((cmd
->fs
.m_ext
.vlan_tci
& cpu_to_be16(VLAN_VID_MASK
)) ==
1283 (cmd
->fs
.m_ext
.vlan_tci
& cpu_to_be16(VLAN_VID_MASK
)) ==
1284 cpu_to_be16(VLAN_VID_MASK
)))
1287 if (cmd
->fs
.m_ext
.vlan_tci
) {
1288 if (be16_to_cpu(cmd
->fs
.h_ext
.vlan_tci
) >= VLAN_N_VID
)
1297 static int mlx4_en_ethtool_add_mac_rule(struct ethtool_rxnfc
*cmd
,
1298 struct list_head
*rule_list_h
,
1299 struct mlx4_spec_list
*spec_l2
,
1303 __be64 mac_msk
= cpu_to_be64(MLX4_MAC_MASK
<< 16);
1305 spec_l2
->id
= MLX4_NET_TRANS_RULE_ID_ETH
;
1306 memcpy(spec_l2
->eth
.dst_mac_msk
, &mac_msk
, ETH_ALEN
);
1307 memcpy(spec_l2
->eth
.dst_mac
, mac
, ETH_ALEN
);
1309 if ((cmd
->fs
.flow_type
& FLOW_EXT
) &&
1310 (cmd
->fs
.m_ext
.vlan_tci
& cpu_to_be16(VLAN_VID_MASK
))) {
1311 spec_l2
->eth
.vlan_id
= cmd
->fs
.h_ext
.vlan_tci
;
1312 spec_l2
->eth
.vlan_id_msk
= cpu_to_be16(VLAN_VID_MASK
);
1315 list_add_tail(&spec_l2
->list
, rule_list_h
);
1320 static int mlx4_en_ethtool_add_mac_rule_by_ipv4(struct mlx4_en_priv
*priv
,
1321 struct ethtool_rxnfc
*cmd
,
1322 struct list_head
*rule_list_h
,
1323 struct mlx4_spec_list
*spec_l2
,
1327 unsigned char mac
[ETH_ALEN
];
1329 if (!ipv4_is_multicast(ipv4_dst
)) {
1330 if (cmd
->fs
.flow_type
& FLOW_MAC_EXT
)
1331 memcpy(&mac
, cmd
->fs
.h_ext
.h_dest
, ETH_ALEN
);
1333 memcpy(&mac
, priv
->dev
->dev_addr
, ETH_ALEN
);
1335 ip_eth_mc_map(ipv4_dst
, mac
);
1338 return mlx4_en_ethtool_add_mac_rule(cmd
, rule_list_h
, spec_l2
, &mac
[0]);
1344 static int add_ip_rule(struct mlx4_en_priv
*priv
,
1345 struct ethtool_rxnfc
*cmd
,
1346 struct list_head
*list_h
)
1349 struct mlx4_spec_list
*spec_l2
= NULL
;
1350 struct mlx4_spec_list
*spec_l3
= NULL
;
1351 struct ethtool_usrip4_spec
*l3_mask
= &cmd
->fs
.m_u
.usr_ip4_spec
;
1353 spec_l3
= kzalloc(sizeof(*spec_l3
), GFP_KERNEL
);
1354 spec_l2
= kzalloc(sizeof(*spec_l2
), GFP_KERNEL
);
1355 if (!spec_l2
|| !spec_l3
) {
1360 err
= mlx4_en_ethtool_add_mac_rule_by_ipv4(priv
, cmd
, list_h
, spec_l2
,
1362 usr_ip4_spec
.ip4dst
);
1365 spec_l3
->id
= MLX4_NET_TRANS_RULE_ID_IPV4
;
1366 spec_l3
->ipv4
.src_ip
= cmd
->fs
.h_u
.usr_ip4_spec
.ip4src
;
1367 if (l3_mask
->ip4src
)
1368 spec_l3
->ipv4
.src_ip_msk
= EN_ETHTOOL_WORD_MASK
;
1369 spec_l3
->ipv4
.dst_ip
= cmd
->fs
.h_u
.usr_ip4_spec
.ip4dst
;
1370 if (l3_mask
->ip4dst
)
1371 spec_l3
->ipv4
.dst_ip_msk
= EN_ETHTOOL_WORD_MASK
;
1372 list_add_tail(&spec_l3
->list
, list_h
);
1382 static int add_tcp_udp_rule(struct mlx4_en_priv
*priv
,
1383 struct ethtool_rxnfc
*cmd
,
1384 struct list_head
*list_h
, int proto
)
1387 struct mlx4_spec_list
*spec_l2
= NULL
;
1388 struct mlx4_spec_list
*spec_l3
= NULL
;
1389 struct mlx4_spec_list
*spec_l4
= NULL
;
1390 struct ethtool_tcpip4_spec
*l4_mask
= &cmd
->fs
.m_u
.tcp_ip4_spec
;
1392 spec_l2
= kzalloc(sizeof(*spec_l2
), GFP_KERNEL
);
1393 spec_l3
= kzalloc(sizeof(*spec_l3
), GFP_KERNEL
);
1394 spec_l4
= kzalloc(sizeof(*spec_l4
), GFP_KERNEL
);
1395 if (!spec_l2
|| !spec_l3
|| !spec_l4
) {
1400 spec_l3
->id
= MLX4_NET_TRANS_RULE_ID_IPV4
;
1402 if (proto
== TCP_V4_FLOW
) {
1403 err
= mlx4_en_ethtool_add_mac_rule_by_ipv4(priv
, cmd
, list_h
,
1406 tcp_ip4_spec
.ip4dst
);
1409 spec_l4
->id
= MLX4_NET_TRANS_RULE_ID_TCP
;
1410 spec_l3
->ipv4
.src_ip
= cmd
->fs
.h_u
.tcp_ip4_spec
.ip4src
;
1411 spec_l3
->ipv4
.dst_ip
= cmd
->fs
.h_u
.tcp_ip4_spec
.ip4dst
;
1412 spec_l4
->tcp_udp
.src_port
= cmd
->fs
.h_u
.tcp_ip4_spec
.psrc
;
1413 spec_l4
->tcp_udp
.dst_port
= cmd
->fs
.h_u
.tcp_ip4_spec
.pdst
;
1415 err
= mlx4_en_ethtool_add_mac_rule_by_ipv4(priv
, cmd
, list_h
,
1418 udp_ip4_spec
.ip4dst
);
1421 spec_l4
->id
= MLX4_NET_TRANS_RULE_ID_UDP
;
1422 spec_l3
->ipv4
.src_ip
= cmd
->fs
.h_u
.udp_ip4_spec
.ip4src
;
1423 spec_l3
->ipv4
.dst_ip
= cmd
->fs
.h_u
.udp_ip4_spec
.ip4dst
;
1424 spec_l4
->tcp_udp
.src_port
= cmd
->fs
.h_u
.udp_ip4_spec
.psrc
;
1425 spec_l4
->tcp_udp
.dst_port
= cmd
->fs
.h_u
.udp_ip4_spec
.pdst
;
1428 if (l4_mask
->ip4src
)
1429 spec_l3
->ipv4
.src_ip_msk
= EN_ETHTOOL_WORD_MASK
;
1430 if (l4_mask
->ip4dst
)
1431 spec_l3
->ipv4
.dst_ip_msk
= EN_ETHTOOL_WORD_MASK
;
1434 spec_l4
->tcp_udp
.src_port_msk
= EN_ETHTOOL_SHORT_MASK
;
1436 spec_l4
->tcp_udp
.dst_port_msk
= EN_ETHTOOL_SHORT_MASK
;
1438 list_add_tail(&spec_l3
->list
, list_h
);
1439 list_add_tail(&spec_l4
->list
, list_h
);
1450 static int mlx4_en_ethtool_to_net_trans_rule(struct net_device
*dev
,
1451 struct ethtool_rxnfc
*cmd
,
1452 struct list_head
*rule_list_h
)
1455 struct ethhdr
*eth_spec
;
1456 struct mlx4_spec_list
*spec_l2
;
1457 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1459 err
= mlx4_en_validate_flow(dev
, cmd
);
1463 switch (cmd
->fs
.flow_type
& ~(FLOW_EXT
| FLOW_MAC_EXT
)) {
1465 spec_l2
= kzalloc(sizeof(*spec_l2
), GFP_KERNEL
);
1469 eth_spec
= &cmd
->fs
.h_u
.ether_spec
;
1470 mlx4_en_ethtool_add_mac_rule(cmd
, rule_list_h
, spec_l2
,
1471 ð_spec
->h_dest
[0]);
1472 spec_l2
->eth
.ether_type
= eth_spec
->h_proto
;
1473 if (eth_spec
->h_proto
)
1474 spec_l2
->eth
.ether_type_enable
= 1;
1477 err
= add_ip_rule(priv
, cmd
, rule_list_h
);
1480 err
= add_tcp_udp_rule(priv
, cmd
, rule_list_h
, TCP_V4_FLOW
);
1483 err
= add_tcp_udp_rule(priv
, cmd
, rule_list_h
, UDP_V4_FLOW
);
1490 static int mlx4_en_flow_replace(struct net_device
*dev
,
1491 struct ethtool_rxnfc
*cmd
)
1494 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1495 struct ethtool_flow_id
*loc_rule
;
1496 struct mlx4_spec_list
*spec
, *tmp_spec
;
1500 struct mlx4_net_trans_rule rule
= {
1501 .queue_mode
= MLX4_NET_TRANS_Q_FIFO
,
1503 .allow_loopback
= 1,
1504 .promisc_mode
= MLX4_FS_REGULAR
,
1507 rule
.port
= priv
->port
;
1508 rule
.priority
= MLX4_DOMAIN_ETHTOOL
| cmd
->fs
.location
;
1509 INIT_LIST_HEAD(&rule
.list
);
1511 /* Allow direct QP attaches if the EN_ETHTOOL_QP_ATTACH flag is set */
1512 if (cmd
->fs
.ring_cookie
== RX_CLS_FLOW_DISC
)
1513 qpn
= priv
->drop_qp
.qpn
;
1514 else if (cmd
->fs
.ring_cookie
& EN_ETHTOOL_QP_ATTACH
) {
1515 qpn
= cmd
->fs
.ring_cookie
& (EN_ETHTOOL_QP_ATTACH
- 1);
1517 if (cmd
->fs
.ring_cookie
>= priv
->rx_ring_num
) {
1518 en_warn(priv
, "rxnfc: RX ring (%llu) doesn't exist\n",
1519 cmd
->fs
.ring_cookie
);
1522 qpn
= priv
->rss_map
.qps
[cmd
->fs
.ring_cookie
].qpn
;
1524 en_warn(priv
, "rxnfc: RX ring (%llu) is inactive\n",
1525 cmd
->fs
.ring_cookie
);
1530 err
= mlx4_en_ethtool_to_net_trans_rule(dev
, cmd
, &rule
.list
);
1534 loc_rule
= &priv
->ethtool_rules
[cmd
->fs
.location
];
1536 err
= mlx4_flow_detach(priv
->mdev
->dev
, loc_rule
->id
);
1538 en_err(priv
, "Fail to detach network rule at location %d. registration id = %llx\n",
1539 cmd
->fs
.location
, loc_rule
->id
);
1543 memset(&loc_rule
->flow_spec
, 0,
1544 sizeof(struct ethtool_rx_flow_spec
));
1545 list_del(&loc_rule
->list
);
1547 err
= mlx4_flow_attach(priv
->mdev
->dev
, &rule
, ®_id
);
1549 en_err(priv
, "Fail to attach network rule at location %d\n",
1553 loc_rule
->id
= reg_id
;
1554 memcpy(&loc_rule
->flow_spec
, &cmd
->fs
,
1555 sizeof(struct ethtool_rx_flow_spec
));
1556 list_add_tail(&loc_rule
->list
, &priv
->ethtool_list
);
1559 list_for_each_entry_safe(spec
, tmp_spec
, &rule
.list
, list
) {
1560 list_del(&spec
->list
);
1566 static int mlx4_en_flow_detach(struct net_device
*dev
,
1567 struct ethtool_rxnfc
*cmd
)
1570 struct ethtool_flow_id
*rule
;
1571 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1573 if (cmd
->fs
.location
>= MAX_NUM_OF_FS_RULES
)
1576 rule
= &priv
->ethtool_rules
[cmd
->fs
.location
];
1582 err
= mlx4_flow_detach(priv
->mdev
->dev
, rule
->id
);
1584 en_err(priv
, "Fail to detach network rule at location %d. registration id = 0x%llx\n",
1585 cmd
->fs
.location
, rule
->id
);
1589 memset(&rule
->flow_spec
, 0, sizeof(struct ethtool_rx_flow_spec
));
1590 list_del(&rule
->list
);
1596 static int mlx4_en_get_flow(struct net_device
*dev
, struct ethtool_rxnfc
*cmd
,
1600 struct ethtool_flow_id
*rule
;
1601 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1603 if (loc
< 0 || loc
>= MAX_NUM_OF_FS_RULES
)
1606 rule
= &priv
->ethtool_rules
[loc
];
1608 memcpy(&cmd
->fs
, &rule
->flow_spec
,
1609 sizeof(struct ethtool_rx_flow_spec
));
1616 static int mlx4_en_get_num_flows(struct mlx4_en_priv
*priv
)
1620 for (i
= 0; i
< MAX_NUM_OF_FS_RULES
; i
++) {
1621 if (priv
->ethtool_rules
[i
].id
)
1628 static int mlx4_en_get_rxnfc(struct net_device
*dev
, struct ethtool_rxnfc
*cmd
,
1631 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1632 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1634 int i
= 0, priority
= 0;
1636 if ((cmd
->cmd
== ETHTOOL_GRXCLSRLCNT
||
1637 cmd
->cmd
== ETHTOOL_GRXCLSRULE
||
1638 cmd
->cmd
== ETHTOOL_GRXCLSRLALL
) &&
1639 (mdev
->dev
->caps
.steering_mode
!=
1640 MLX4_STEERING_MODE_DEVICE_MANAGED
|| !priv
->port_up
))
1644 case ETHTOOL_GRXRINGS
:
1645 cmd
->data
= priv
->rx_ring_num
;
1647 case ETHTOOL_GRXCLSRLCNT
:
1648 cmd
->rule_cnt
= mlx4_en_get_num_flows(priv
);
1650 case ETHTOOL_GRXCLSRULE
:
1651 err
= mlx4_en_get_flow(dev
, cmd
, cmd
->fs
.location
);
1653 case ETHTOOL_GRXCLSRLALL
:
1654 while ((!err
|| err
== -ENOENT
) && priority
< cmd
->rule_cnt
) {
1655 err
= mlx4_en_get_flow(dev
, cmd
, i
);
1657 rule_locs
[priority
++] = i
;
1670 static int mlx4_en_set_rxnfc(struct net_device
*dev
, struct ethtool_rxnfc
*cmd
)
1673 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1674 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1676 if (mdev
->dev
->caps
.steering_mode
!=
1677 MLX4_STEERING_MODE_DEVICE_MANAGED
|| !priv
->port_up
)
1681 case ETHTOOL_SRXCLSRLINS
:
1682 err
= mlx4_en_flow_replace(dev
, cmd
);
1684 case ETHTOOL_SRXCLSRLDEL
:
1685 err
= mlx4_en_flow_detach(dev
, cmd
);
1688 en_warn(priv
, "Unsupported ethtool command. (%d)\n", cmd
->cmd
);
1695 static void mlx4_en_get_channels(struct net_device
*dev
,
1696 struct ethtool_channels
*channel
)
1698 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1700 memset(channel
, 0, sizeof(*channel
));
1702 channel
->max_rx
= MAX_RX_RINGS
;
1703 channel
->max_tx
= MLX4_EN_MAX_TX_RING_P_UP
;
1705 channel
->rx_count
= priv
->rx_ring_num
;
1706 channel
->tx_count
= priv
->tx_ring_num
/ MLX4_EN_NUM_UP
;
1709 static int mlx4_en_set_channels(struct net_device
*dev
,
1710 struct ethtool_channels
*channel
)
1712 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1713 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1717 if (channel
->other_count
|| channel
->combined_count
||
1718 channel
->tx_count
> MLX4_EN_MAX_TX_RING_P_UP
||
1719 channel
->rx_count
> MAX_RX_RINGS
||
1720 !channel
->tx_count
|| !channel
->rx_count
)
1723 mutex_lock(&mdev
->state_lock
);
1724 if (priv
->port_up
) {
1726 mlx4_en_stop_port(dev
, 1);
1729 mlx4_en_free_resources(priv
);
1731 priv
->num_tx_rings_p_up
= channel
->tx_count
;
1732 priv
->tx_ring_num
= channel
->tx_count
* MLX4_EN_NUM_UP
;
1733 priv
->rx_ring_num
= channel
->rx_count
;
1735 err
= mlx4_en_alloc_resources(priv
);
1737 en_err(priv
, "Failed reallocating port resources\n");
1741 netif_set_real_num_tx_queues(dev
, priv
->tx_ring_num
);
1742 netif_set_real_num_rx_queues(dev
, priv
->rx_ring_num
);
1745 mlx4_en_setup_tc(dev
, MLX4_EN_NUM_UP
);
1747 en_warn(priv
, "Using %d TX rings\n", priv
->tx_ring_num
);
1748 en_warn(priv
, "Using %d RX rings\n", priv
->rx_ring_num
);
1751 err
= mlx4_en_start_port(dev
);
1753 en_err(priv
, "Failed starting port\n");
1756 err
= mlx4_en_moderation_update(priv
);
1759 mutex_unlock(&mdev
->state_lock
);
1763 static int mlx4_en_get_ts_info(struct net_device
*dev
,
1764 struct ethtool_ts_info
*info
)
1766 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1767 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1770 ret
= ethtool_op_get_ts_info(dev
, info
);
1774 if (mdev
->dev
->caps
.flags2
& MLX4_DEV_CAP_FLAG2_TS
) {
1775 info
->so_timestamping
|=
1776 SOF_TIMESTAMPING_TX_HARDWARE
|
1777 SOF_TIMESTAMPING_RX_HARDWARE
|
1778 SOF_TIMESTAMPING_RAW_HARDWARE
;
1781 (1 << HWTSTAMP_TX_OFF
) |
1782 (1 << HWTSTAMP_TX_ON
);
1785 (1 << HWTSTAMP_FILTER_NONE
) |
1786 (1 << HWTSTAMP_FILTER_ALL
);
1788 if (mdev
->ptp_clock
)
1789 info
->phc_index
= ptp_clock_index(mdev
->ptp_clock
);
1795 static int mlx4_en_set_priv_flags(struct net_device
*dev
, u32 flags
)
1797 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1798 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1799 bool bf_enabled_new
= !!(flags
& MLX4_EN_PRIV_FLAGS_BLUEFLAME
);
1800 bool bf_enabled_old
= !!(priv
->pflags
& MLX4_EN_PRIV_FLAGS_BLUEFLAME
);
1801 bool phv_enabled_new
= !!(flags
& MLX4_EN_PRIV_FLAGS_PHV
);
1802 bool phv_enabled_old
= !!(priv
->pflags
& MLX4_EN_PRIV_FLAGS_PHV
);
1806 if (bf_enabled_new
!= bf_enabled_old
) {
1807 if (bf_enabled_new
) {
1808 bool bf_supported
= true;
1810 for (i
= 0; i
< priv
->tx_ring_num
; i
++)
1811 bf_supported
&= priv
->tx_ring
[i
]->bf_alloced
;
1813 if (!bf_supported
) {
1814 en_err(priv
, "BlueFlame is not supported\n");
1818 priv
->pflags
|= MLX4_EN_PRIV_FLAGS_BLUEFLAME
;
1820 priv
->pflags
&= ~MLX4_EN_PRIV_FLAGS_BLUEFLAME
;
1823 for (i
= 0; i
< priv
->tx_ring_num
; i
++)
1824 priv
->tx_ring
[i
]->bf_enabled
= bf_enabled_new
;
1826 en_info(priv
, "BlueFlame %s\n",
1827 bf_enabled_new
? "Enabled" : "Disabled");
1830 if (phv_enabled_new
!= phv_enabled_old
) {
1831 ret
= set_phv_bit(mdev
->dev
, priv
->port
, (int)phv_enabled_new
);
1834 else if (phv_enabled_new
)
1835 priv
->pflags
|= MLX4_EN_PRIV_FLAGS_PHV
;
1837 priv
->pflags
&= ~MLX4_EN_PRIV_FLAGS_PHV
;
1838 en_info(priv
, "PHV bit %s\n",
1839 phv_enabled_new
? "Enabled" : "Disabled");
1844 static u32
mlx4_en_get_priv_flags(struct net_device
*dev
)
1846 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1848 return priv
->pflags
;
1851 static int mlx4_en_get_tunable(struct net_device
*dev
,
1852 const struct ethtool_tunable
*tuna
,
1855 const struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1859 case ETHTOOL_TX_COPYBREAK
:
1860 *(u32
*)data
= priv
->prof
->inline_thold
;
1870 static int mlx4_en_set_tunable(struct net_device
*dev
,
1871 const struct ethtool_tunable
*tuna
,
1874 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1878 case ETHTOOL_TX_COPYBREAK
:
1880 if (val
< MIN_PKT_LEN
|| val
> MAX_INLINE
)
1883 priv
->prof
->inline_thold
= val
;
1893 static int mlx4_en_get_module_info(struct net_device
*dev
,
1894 struct ethtool_modinfo
*modinfo
)
1896 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1897 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1901 /* Read first 2 bytes to get Module & REV ID */
1902 ret
= mlx4_get_module_info(mdev
->dev
, priv
->port
,
1903 0/*offset*/, 2/*size*/, data
);
1907 switch (data
[0] /* identifier */) {
1908 case MLX4_MODULE_ID_QSFP
:
1909 modinfo
->type
= ETH_MODULE_SFF_8436
;
1910 modinfo
->eeprom_len
= ETH_MODULE_SFF_8436_LEN
;
1912 case MLX4_MODULE_ID_QSFP_PLUS
:
1913 if (data
[1] >= 0x3) { /* revision id */
1914 modinfo
->type
= ETH_MODULE_SFF_8636
;
1915 modinfo
->eeprom_len
= ETH_MODULE_SFF_8636_LEN
;
1917 modinfo
->type
= ETH_MODULE_SFF_8436
;
1918 modinfo
->eeprom_len
= ETH_MODULE_SFF_8436_LEN
;
1921 case MLX4_MODULE_ID_QSFP28
:
1922 modinfo
->type
= ETH_MODULE_SFF_8636
;
1923 modinfo
->eeprom_len
= ETH_MODULE_SFF_8636_LEN
;
1925 case MLX4_MODULE_ID_SFP
:
1926 modinfo
->type
= ETH_MODULE_SFF_8472
;
1927 modinfo
->eeprom_len
= ETH_MODULE_SFF_8472_LEN
;
1936 static int mlx4_en_get_module_eeprom(struct net_device
*dev
,
1937 struct ethtool_eeprom
*ee
,
1940 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1941 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1942 int offset
= ee
->offset
;
1948 memset(data
, 0, ee
->len
);
1950 while (i
< ee
->len
) {
1952 "mlx4_get_module_info i(%d) offset(%d) len(%d)\n",
1953 i
, offset
, ee
->len
- i
);
1955 ret
= mlx4_get_module_info(mdev
->dev
, priv
->port
,
1956 offset
, ee
->len
- i
, data
+ i
);
1958 if (!ret
) /* Done reading */
1963 "mlx4_get_module_info i(%d) offset(%d) bytes_to_read(%d) - FAILED (0x%x)\n",
1964 i
, offset
, ee
->len
- i
, ret
);
1974 static int mlx4_en_set_phys_id(struct net_device
*dev
,
1975 enum ethtool_phys_id_state state
)
1978 u16 beacon_duration
;
1979 struct mlx4_en_priv
*priv
= netdev_priv(dev
);
1980 struct mlx4_en_dev
*mdev
= priv
->mdev
;
1982 if (!(mdev
->dev
->caps
.flags2
& MLX4_DEV_CAP_FLAG2_PORT_BEACON
))
1986 case ETHTOOL_ID_ACTIVE
:
1987 beacon_duration
= PORT_BEACON_MAX_LIMIT
;
1989 case ETHTOOL_ID_INACTIVE
:
1990 beacon_duration
= 0;
1996 err
= mlx4_SET_PORT_BEACON(mdev
->dev
, priv
->port
, beacon_duration
);
2000 const struct ethtool_ops mlx4_en_ethtool_ops
= {
2001 .get_drvinfo
= mlx4_en_get_drvinfo
,
2002 .get_link_ksettings
= mlx4_en_get_link_ksettings
,
2003 .set_link_ksettings
= mlx4_en_set_link_ksettings
,
2004 .get_link
= ethtool_op_get_link
,
2005 .get_strings
= mlx4_en_get_strings
,
2006 .get_sset_count
= mlx4_en_get_sset_count
,
2007 .get_ethtool_stats
= mlx4_en_get_ethtool_stats
,
2008 .self_test
= mlx4_en_self_test
,
2009 .set_phys_id
= mlx4_en_set_phys_id
,
2010 .get_wol
= mlx4_en_get_wol
,
2011 .set_wol
= mlx4_en_set_wol
,
2012 .get_msglevel
= mlx4_en_get_msglevel
,
2013 .set_msglevel
= mlx4_en_set_msglevel
,
2014 .get_coalesce
= mlx4_en_get_coalesce
,
2015 .set_coalesce
= mlx4_en_set_coalesce
,
2016 .get_pauseparam
= mlx4_en_get_pauseparam
,
2017 .set_pauseparam
= mlx4_en_set_pauseparam
,
2018 .get_ringparam
= mlx4_en_get_ringparam
,
2019 .set_ringparam
= mlx4_en_set_ringparam
,
2020 .get_rxnfc
= mlx4_en_get_rxnfc
,
2021 .set_rxnfc
= mlx4_en_set_rxnfc
,
2022 .get_rxfh_indir_size
= mlx4_en_get_rxfh_indir_size
,
2023 .get_rxfh_key_size
= mlx4_en_get_rxfh_key_size
,
2024 .get_rxfh
= mlx4_en_get_rxfh
,
2025 .set_rxfh
= mlx4_en_set_rxfh
,
2026 .get_channels
= mlx4_en_get_channels
,
2027 .set_channels
= mlx4_en_set_channels
,
2028 .get_ts_info
= mlx4_en_get_ts_info
,
2029 .set_priv_flags
= mlx4_en_set_priv_flags
,
2030 .get_priv_flags
= mlx4_en_get_priv_flags
,
2031 .get_tunable
= mlx4_en_get_tunable
,
2032 .set_tunable
= mlx4_en_set_tunable
,
2033 .get_module_info
= mlx4_en_get_module_info
,
2034 .get_module_eeprom
= mlx4_en_get_module_eeprom