1 /*
2 * Copyright (c) 2015, Mellanox Technologies. All rights reserved.
3 *
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
9 *
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
12 * conditions are met:
13 *
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
16 * disclaimer.
17 *
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 * SOFTWARE.
31 */
32
33 #include <linux/dim.h>
34 #include <linux/ethtool_netlink.h>
35 #include <net/netdev_queues.h>
36
37 #include "en.h"
38 #include "en/channels.h"
39 #include "en/dim.h"
40 #include "en/port.h"
41 #include "en/params.h"
42 #include "en/ptp.h"
43 #include "lib/clock.h"
44 #include "en/fs_ethtool.h"
45
46 #define LANES_UNKNOWN 0
47
mlx5e_ethtool_get_drvinfo(struct mlx5e_priv * priv,struct ethtool_drvinfo * drvinfo)48 void mlx5e_ethtool_get_drvinfo(struct mlx5e_priv *priv,
49 struct ethtool_drvinfo *drvinfo)
50 {
51 struct mlx5_core_dev *mdev = priv->mdev;
52 int count;
53
54 strscpy(drvinfo->driver, KBUILD_MODNAME, sizeof(drvinfo->driver));
55 count = snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
56 "%d.%d.%04d (%.16s)", fw_rev_maj(mdev),
57 fw_rev_min(mdev), fw_rev_sub(mdev), mdev->board_id);
58 if (count >= sizeof(drvinfo->fw_version))
59 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
60 "%d.%d.%04d", fw_rev_maj(mdev),
61 fw_rev_min(mdev), fw_rev_sub(mdev));
62
63 strscpy(drvinfo->bus_info, dev_name(mdev->device),
64 sizeof(drvinfo->bus_info));
65 }
66
mlx5e_get_drvinfo(struct net_device * dev,struct ethtool_drvinfo * drvinfo)67 static void mlx5e_get_drvinfo(struct net_device *dev,
68 struct ethtool_drvinfo *drvinfo)
69 {
70 struct mlx5e_priv *priv = netdev_priv(dev);
71
72 mlx5e_ethtool_get_drvinfo(priv, drvinfo);
73 }
74
75 struct ptys2ethtool_config {
76 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported);
77 __ETHTOOL_DECLARE_LINK_MODE_MASK(advertised);
78 };
79
80 static
81 struct ptys2ethtool_config ptys2legacy_ethtool_table[MLX5E_LINK_MODES_NUMBER];
82 static
83 struct ptys2ethtool_config ptys2ext_ethtool_table[MLX5E_EXT_LINK_MODES_NUMBER];
84
85 #define MLX5_BUILD_PTYS2ETHTOOL_CONFIG(reg_, table, ...) \
86 ({ \
87 struct ptys2ethtool_config *cfg; \
88 const unsigned int modes[] = { __VA_ARGS__ }; \
89 unsigned int i; \
90 cfg = &ptys2##table##_ethtool_table[reg_]; \
91 bitmap_zero(cfg->supported, \
92 __ETHTOOL_LINK_MODE_MASK_NBITS); \
93 bitmap_zero(cfg->advertised, \
94 __ETHTOOL_LINK_MODE_MASK_NBITS); \
95 for (i = 0 ; i < ARRAY_SIZE(modes) ; ++i) { \
96 bitmap_set(cfg->supported, modes[i], 1); \
97 bitmap_set(cfg->advertised, modes[i], 1); \
98 } \
99 })
100
mlx5e_build_ptys2ethtool_map(void)101 void mlx5e_build_ptys2ethtool_map(void)
102 {
103 memset(ptys2legacy_ethtool_table, 0, sizeof(ptys2legacy_ethtool_table));
104 memset(ptys2ext_ethtool_table, 0, sizeof(ptys2ext_ethtool_table));
105 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_1000BASE_CX_SGMII, legacy,
106 ETHTOOL_LINK_MODE_1000baseKX_Full_BIT);
107 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_1000BASE_KX, legacy,
108 ETHTOOL_LINK_MODE_1000baseKX_Full_BIT);
109 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_10GBASE_CX4, legacy,
110 ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT);
111 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_10GBASE_KX4, legacy,
112 ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT);
113 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_10GBASE_KR, legacy,
114 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT);
115 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_20GBASE_KR2, legacy,
116 ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT);
117 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_40GBASE_CR4, legacy,
118 ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT);
119 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_40GBASE_KR4, legacy,
120 ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT);
121 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_56GBASE_R4, legacy,
122 ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT);
123 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_10GBASE_CR, legacy,
124 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT);
125 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_10GBASE_SR, legacy,
126 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT);
127 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_10GBASE_ER, legacy,
128 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT);
129 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_40GBASE_SR4, legacy,
130 ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT);
131 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_40GBASE_LR4, legacy,
132 ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT);
133 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_50GBASE_SR2, legacy,
134 ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT);
135 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_100GBASE_CR4, legacy,
136 ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT);
137 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_100GBASE_SR4, legacy,
138 ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT);
139 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_100GBASE_KR4, legacy,
140 ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT);
141 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_100GBASE_LR4, legacy,
142 ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT);
143 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_100BASE_TX, legacy,
144 ETHTOOL_LINK_MODE_100baseT_Full_BIT);
145 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_1000BASE_T, legacy,
146 ETHTOOL_LINK_MODE_1000baseT_Full_BIT);
147 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_10GBASE_T, legacy,
148 ETHTOOL_LINK_MODE_10000baseT_Full_BIT);
149 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_25GBASE_CR, legacy,
150 ETHTOOL_LINK_MODE_25000baseCR_Full_BIT);
151 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_25GBASE_KR, legacy,
152 ETHTOOL_LINK_MODE_25000baseKR_Full_BIT);
153 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_25GBASE_SR, legacy,
154 ETHTOOL_LINK_MODE_25000baseSR_Full_BIT);
155 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_50GBASE_CR2, legacy,
156 ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT);
157 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_50GBASE_KR2, legacy,
158 ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT);
159 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_SGMII_100M, ext,
160 ETHTOOL_LINK_MODE_100baseT_Full_BIT);
161 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_1000BASE_X_SGMII, ext,
162 ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
163 ETHTOOL_LINK_MODE_1000baseKX_Full_BIT,
164 ETHTOOL_LINK_MODE_1000baseX_Full_BIT);
165 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_5GBASE_R, ext,
166 ETHTOOL_LINK_MODE_5000baseT_Full_BIT);
167 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_10GBASE_XFI_XAUI_1, ext,
168 ETHTOOL_LINK_MODE_10000baseT_Full_BIT,
169 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT,
170 ETHTOOL_LINK_MODE_10000baseR_FEC_BIT,
171 ETHTOOL_LINK_MODE_10000baseCR_Full_BIT,
172 ETHTOOL_LINK_MODE_10000baseSR_Full_BIT,
173 ETHTOOL_LINK_MODE_10000baseLR_Full_BIT,
174 ETHTOOL_LINK_MODE_10000baseER_Full_BIT);
175 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_40GBASE_XLAUI_4_XLPPI_4, ext,
176 ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT,
177 ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT,
178 ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT,
179 ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT);
180 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_25GAUI_1_25GBASE_CR_KR, ext,
181 ETHTOOL_LINK_MODE_25000baseCR_Full_BIT,
182 ETHTOOL_LINK_MODE_25000baseKR_Full_BIT,
183 ETHTOOL_LINK_MODE_25000baseSR_Full_BIT);
184 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_50GAUI_2_LAUI_2_50GBASE_CR2_KR2,
185 ext,
186 ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT,
187 ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT,
188 ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT);
189 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_50GAUI_1_LAUI_1_50GBASE_CR_KR, ext,
190 ETHTOOL_LINK_MODE_50000baseKR_Full_BIT,
191 ETHTOOL_LINK_MODE_50000baseSR_Full_BIT,
192 ETHTOOL_LINK_MODE_50000baseCR_Full_BIT,
193 ETHTOOL_LINK_MODE_50000baseLR_ER_FR_Full_BIT,
194 ETHTOOL_LINK_MODE_50000baseDR_Full_BIT);
195 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_CAUI_4_100GBASE_CR4_KR4, ext,
196 ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT,
197 ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT,
198 ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT,
199 ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT);
200 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_100GAUI_2_100GBASE_CR2_KR2, ext,
201 ETHTOOL_LINK_MODE_100000baseKR2_Full_BIT,
202 ETHTOOL_LINK_MODE_100000baseSR2_Full_BIT,
203 ETHTOOL_LINK_MODE_100000baseCR2_Full_BIT,
204 ETHTOOL_LINK_MODE_100000baseLR2_ER2_FR2_Full_BIT,
205 ETHTOOL_LINK_MODE_100000baseDR2_Full_BIT);
206 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_200GAUI_4_200GBASE_CR4_KR4, ext,
207 ETHTOOL_LINK_MODE_200000baseKR4_Full_BIT,
208 ETHTOOL_LINK_MODE_200000baseSR4_Full_BIT,
209 ETHTOOL_LINK_MODE_200000baseLR4_ER4_FR4_Full_BIT,
210 ETHTOOL_LINK_MODE_200000baseDR4_Full_BIT,
211 ETHTOOL_LINK_MODE_200000baseCR4_Full_BIT);
212 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_400GAUI_8_400GBASE_CR8, ext,
213 ETHTOOL_LINK_MODE_400000baseKR8_Full_BIT,
214 ETHTOOL_LINK_MODE_400000baseSR8_Full_BIT,
215 ETHTOOL_LINK_MODE_400000baseLR8_ER8_FR8_Full_BIT,
216 ETHTOOL_LINK_MODE_400000baseDR8_Full_BIT,
217 ETHTOOL_LINK_MODE_400000baseCR8_Full_BIT);
218 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_100GAUI_1_100GBASE_CR_KR, ext,
219 ETHTOOL_LINK_MODE_100000baseKR_Full_BIT,
220 ETHTOOL_LINK_MODE_100000baseSR_Full_BIT,
221 ETHTOOL_LINK_MODE_100000baseLR_ER_FR_Full_BIT,
222 ETHTOOL_LINK_MODE_100000baseDR_Full_BIT,
223 ETHTOOL_LINK_MODE_100000baseCR_Full_BIT);
224 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_200GAUI_2_200GBASE_CR2_KR2, ext,
225 ETHTOOL_LINK_MODE_200000baseKR2_Full_BIT,
226 ETHTOOL_LINK_MODE_200000baseSR2_Full_BIT,
227 ETHTOOL_LINK_MODE_200000baseLR2_ER2_FR2_Full_BIT,
228 ETHTOOL_LINK_MODE_200000baseDR2_Full_BIT,
229 ETHTOOL_LINK_MODE_200000baseCR2_Full_BIT);
230 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_400GAUI_4_400GBASE_CR4_KR4, ext,
231 ETHTOOL_LINK_MODE_400000baseKR4_Full_BIT,
232 ETHTOOL_LINK_MODE_400000baseSR4_Full_BIT,
233 ETHTOOL_LINK_MODE_400000baseLR4_ER4_FR4_Full_BIT,
234 ETHTOOL_LINK_MODE_400000baseDR4_Full_BIT,
235 ETHTOOL_LINK_MODE_400000baseCR4_Full_BIT);
236 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_800GAUI_8_800GBASE_CR8_KR8, ext,
237 ETHTOOL_LINK_MODE_800000baseCR8_Full_BIT,
238 ETHTOOL_LINK_MODE_800000baseKR8_Full_BIT,
239 ETHTOOL_LINK_MODE_800000baseDR8_Full_BIT,
240 ETHTOOL_LINK_MODE_800000baseDR8_2_Full_BIT,
241 ETHTOOL_LINK_MODE_800000baseSR8_Full_BIT,
242 ETHTOOL_LINK_MODE_800000baseVR8_Full_BIT);
243 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_200GAUI_1_200GBASE_CR1_KR1, ext,
244 ETHTOOL_LINK_MODE_200000baseCR_Full_BIT,
245 ETHTOOL_LINK_MODE_200000baseKR_Full_BIT,
246 ETHTOOL_LINK_MODE_200000baseDR_Full_BIT,
247 ETHTOOL_LINK_MODE_200000baseDR_2_Full_BIT,
248 ETHTOOL_LINK_MODE_200000baseSR_Full_BIT,
249 ETHTOOL_LINK_MODE_200000baseVR_Full_BIT);
250 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_400GAUI_2_400GBASE_CR2_KR2, ext,
251 ETHTOOL_LINK_MODE_400000baseCR2_Full_BIT,
252 ETHTOOL_LINK_MODE_400000baseKR2_Full_BIT,
253 ETHTOOL_LINK_MODE_400000baseDR2_Full_BIT,
254 ETHTOOL_LINK_MODE_400000baseDR2_2_Full_BIT,
255 ETHTOOL_LINK_MODE_400000baseSR2_Full_BIT,
256 ETHTOOL_LINK_MODE_400000baseVR2_Full_BIT);
257 MLX5_BUILD_PTYS2ETHTOOL_CONFIG(MLX5E_800GAUI_4_800GBASE_CR4_KR4, ext,
258 ETHTOOL_LINK_MODE_800000baseCR4_Full_BIT,
259 ETHTOOL_LINK_MODE_800000baseKR4_Full_BIT,
260 ETHTOOL_LINK_MODE_800000baseDR4_Full_BIT,
261 ETHTOOL_LINK_MODE_800000baseDR4_2_Full_BIT,
262 ETHTOOL_LINK_MODE_800000baseSR4_Full_BIT,
263 ETHTOOL_LINK_MODE_800000baseVR4_Full_BIT);
264 }
265
mlx5e_ethtool_get_speed_arr(bool ext,struct ptys2ethtool_config ** arr,u32 * size)266 static void mlx5e_ethtool_get_speed_arr(bool ext,
267 struct ptys2ethtool_config **arr,
268 u32 *size)
269 {
270 *arr = ext ? ptys2ext_ethtool_table : ptys2legacy_ethtool_table;
271 *size = ext ? ARRAY_SIZE(ptys2ext_ethtool_table) :
272 ARRAY_SIZE(ptys2legacy_ethtool_table);
273 }
274
275 typedef int (*mlx5e_pflag_handler)(struct net_device *netdev, bool enable);
276
277 struct pflag_desc {
278 char name[ETH_GSTRING_LEN];
279 mlx5e_pflag_handler handler;
280 };
281
282 static const struct pflag_desc mlx5e_priv_flags[MLX5E_NUM_PFLAGS];
283
mlx5e_ethtool_get_sset_count(struct mlx5e_priv * priv,int sset)284 int mlx5e_ethtool_get_sset_count(struct mlx5e_priv *priv, int sset)
285 {
286 switch (sset) {
287 case ETH_SS_STATS:
288 return mlx5e_stats_total_num(priv);
289 case ETH_SS_PRIV_FLAGS:
290 return MLX5E_NUM_PFLAGS;
291 case ETH_SS_TEST:
292 return mlx5e_self_test_num(priv);
293 default:
294 return -EOPNOTSUPP;
295 }
296 }
297
mlx5e_get_sset_count(struct net_device * dev,int sset)298 static int mlx5e_get_sset_count(struct net_device *dev, int sset)
299 {
300 struct mlx5e_priv *priv = netdev_priv(dev);
301
302 return mlx5e_ethtool_get_sset_count(priv, sset);
303 }
304
mlx5e_ethtool_get_strings(struct mlx5e_priv * priv,u32 stringset,u8 * data)305 void mlx5e_ethtool_get_strings(struct mlx5e_priv *priv, u32 stringset, u8 *data)
306 {
307 int i;
308
309 switch (stringset) {
310 case ETH_SS_PRIV_FLAGS:
311 for (i = 0; i < MLX5E_NUM_PFLAGS; i++)
312 ethtool_puts(&data, mlx5e_priv_flags[i].name);
313 break;
314
315 case ETH_SS_TEST:
316 mlx5e_self_test_fill_strings(priv, data);
317 break;
318
319 case ETH_SS_STATS:
320 mlx5e_stats_fill_strings(priv, data);
321 break;
322 }
323 }
324
mlx5e_get_strings(struct net_device * dev,u32 stringset,u8 * data)325 static void mlx5e_get_strings(struct net_device *dev, u32 stringset, u8 *data)
326 {
327 struct mlx5e_priv *priv = netdev_priv(dev);
328
329 mlx5e_ethtool_get_strings(priv, stringset, data);
330 }
331
mlx5e_ethtool_get_ethtool_stats(struct mlx5e_priv * priv,struct ethtool_stats * stats,u64 * data)332 void mlx5e_ethtool_get_ethtool_stats(struct mlx5e_priv *priv,
333 struct ethtool_stats *stats, u64 *data)
334 {
335 int idx = 0;
336
337 mutex_lock(&priv->state_lock);
338 mlx5e_stats_update(priv);
339 mutex_unlock(&priv->state_lock);
340
341 mlx5e_stats_fill(priv, data, idx);
342 }
343
mlx5e_get_ethtool_stats(struct net_device * dev,struct ethtool_stats * stats,u64 * data)344 static void mlx5e_get_ethtool_stats(struct net_device *dev,
345 struct ethtool_stats *stats,
346 u64 *data)
347 {
348 struct mlx5e_priv *priv = netdev_priv(dev);
349
350 mlx5e_ethtool_get_ethtool_stats(priv, stats, data);
351 }
352
mlx5e_ethtool_get_ringparam(struct mlx5e_priv * priv,struct ethtool_ringparam * param,struct kernel_ethtool_ringparam * kernel_param)353 void mlx5e_ethtool_get_ringparam(struct mlx5e_priv *priv,
354 struct ethtool_ringparam *param,
355 struct kernel_ethtool_ringparam *kernel_param)
356 {
357 /* Limitation for regular RQ. XSK RQ may clamp the queue length in
358 * mlx5e_mpwqe_get_log_rq_size.
359 */
360 u8 max_log_mpwrq_pkts = mlx5e_mpwrq_max_log_rq_pkts(priv->mdev,
361 PAGE_SHIFT,
362 MLX5E_MPWRQ_UMR_MODE_ALIGNED);
363
364 param->rx_max_pending = 1 << min_t(u8, MLX5E_PARAMS_MAXIMUM_LOG_RQ_SIZE,
365 max_log_mpwrq_pkts);
366 param->tx_max_pending = 1 << MLX5E_PARAMS_MAXIMUM_LOG_SQ_SIZE;
367 param->rx_pending = 1 << priv->channels.params.log_rq_mtu_frames;
368 param->tx_pending = 1 << priv->channels.params.log_sq_size;
369 }
370
mlx5e_get_ringparam(struct net_device * dev,struct ethtool_ringparam * param,struct kernel_ethtool_ringparam * kernel_param,struct netlink_ext_ack * extack)371 static void mlx5e_get_ringparam(struct net_device *dev,
372 struct ethtool_ringparam *param,
373 struct kernel_ethtool_ringparam *kernel_param,
374 struct netlink_ext_ack *extack)
375 {
376 struct mlx5e_priv *priv = netdev_priv(dev);
377
378 mlx5e_ethtool_get_ringparam(priv, param, kernel_param);
379 }
380
mlx5e_ethtool_set_tcp_data_split(struct mlx5e_priv * priv,u8 tcp_data_split,struct netlink_ext_ack * extack)381 static bool mlx5e_ethtool_set_tcp_data_split(struct mlx5e_priv *priv,
382 u8 tcp_data_split,
383 struct netlink_ext_ack *extack)
384 {
385 struct net_device *dev = priv->netdev;
386
387 if (tcp_data_split == ETHTOOL_TCP_DATA_SPLIT_ENABLED &&
388 !(dev->features & NETIF_F_GRO_HW)) {
389 NL_SET_ERR_MSG_MOD(extack,
390 "TCP-data-split is not supported when GRO HW is disabled");
391 return false;
392 }
393
394 /* Might need to disable HW-GRO if it was kept on due to hds. */
395 if (tcp_data_split == ETHTOOL_TCP_DATA_SPLIT_DISABLED &&
396 dev->cfg->hds_config == ETHTOOL_TCP_DATA_SPLIT_ENABLED)
397 netdev_update_features(priv->netdev);
398
399 return true;
400 }
401
mlx5e_ethtool_set_ringparam(struct mlx5e_priv * priv,struct ethtool_ringparam * param,struct netlink_ext_ack * extack)402 int mlx5e_ethtool_set_ringparam(struct mlx5e_priv *priv,
403 struct ethtool_ringparam *param,
404 struct netlink_ext_ack *extack)
405 {
406 struct mlx5e_params new_params;
407 u8 log_rq_size;
408 u8 log_sq_size;
409 int err = 0;
410
411 if (param->rx_pending < (1 << MLX5E_PARAMS_MINIMUM_LOG_RQ_SIZE)) {
412 NL_SET_ERR_MSG_FMT_MOD(extack, "rx (%d) < min (%d)",
413 param->rx_pending,
414 1 << MLX5E_PARAMS_MINIMUM_LOG_RQ_SIZE);
415 return -EINVAL;
416 }
417
418 if (param->tx_pending < (1 << MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE)) {
419 NL_SET_ERR_MSG_FMT_MOD(extack, "tx (%d) < min (%d)",
420 param->tx_pending,
421 1 << MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE);
422 return -EINVAL;
423 }
424
425 log_rq_size = order_base_2(param->rx_pending);
426 log_sq_size = order_base_2(param->tx_pending);
427
428 if (log_rq_size == priv->channels.params.log_rq_mtu_frames &&
429 log_sq_size == priv->channels.params.log_sq_size)
430 return 0;
431
432 mutex_lock(&priv->state_lock);
433
434 new_params = priv->channels.params;
435 new_params.log_rq_mtu_frames = log_rq_size;
436 new_params.log_sq_size = log_sq_size;
437
438 err = mlx5e_validate_params(priv->mdev, &new_params);
439 if (err)
440 goto unlock;
441
442 err = mlx5e_safe_switch_params(priv, &new_params, NULL, NULL, true);
443
444 unlock:
445 mutex_unlock(&priv->state_lock);
446
447 if (!err)
448 netdev_update_features(priv->netdev);
449
450 return err;
451 }
452
mlx5e_set_ringparam(struct net_device * dev,struct ethtool_ringparam * param,struct kernel_ethtool_ringparam * kernel_param,struct netlink_ext_ack * extack)453 static int mlx5e_set_ringparam(struct net_device *dev,
454 struct ethtool_ringparam *param,
455 struct kernel_ethtool_ringparam *kernel_param,
456 struct netlink_ext_ack *extack)
457 {
458 struct mlx5e_priv *priv = netdev_priv(dev);
459
460 if (!mlx5e_ethtool_set_tcp_data_split(priv,
461 kernel_param->tcp_data_split,
462 extack))
463 return -EINVAL;
464
465 return mlx5e_ethtool_set_ringparam(priv, param, extack);
466 }
467
mlx5e_ethtool_get_channels(struct mlx5e_priv * priv,struct ethtool_channels * ch)468 void mlx5e_ethtool_get_channels(struct mlx5e_priv *priv,
469 struct ethtool_channels *ch)
470 {
471 mutex_lock(&priv->state_lock);
472 ch->max_combined = priv->max_nch;
473 ch->combined_count = priv->channels.params.num_channels;
474 mutex_unlock(&priv->state_lock);
475 }
476
mlx5e_get_channels(struct net_device * dev,struct ethtool_channels * ch)477 static void mlx5e_get_channels(struct net_device *dev,
478 struct ethtool_channels *ch)
479 {
480 struct mlx5e_priv *priv = netdev_priv(dev);
481
482 mlx5e_ethtool_get_channels(priv, ch);
483 }
484
mlx5e_ethtool_set_channels(struct mlx5e_priv * priv,struct ethtool_channels * ch)485 int mlx5e_ethtool_set_channels(struct mlx5e_priv *priv,
486 struct ethtool_channels *ch)
487 {
488 struct mlx5e_params *cur_params = &priv->channels.params;
489 unsigned int count = ch->combined_count;
490 struct mlx5e_params new_params;
491 bool arfs_enabled;
492 bool opened;
493 int err = 0;
494
495 if (!count) {
496 netdev_info(priv->netdev, "%s: combined_count=0 not supported\n",
497 __func__);
498 return -EINVAL;
499 }
500
501 if (cur_params->num_channels == count)
502 return 0;
503
504 mutex_lock(&priv->state_lock);
505
506 if (mlx5e_rx_res_get_current_hash(priv->rx_res).hfunc == ETH_RSS_HASH_XOR) {
507 unsigned int xor8_max_channels = mlx5e_rqt_max_num_channels_allowed_for_xor8();
508
509 if (count > xor8_max_channels) {
510 err = -EINVAL;
511 netdev_err(priv->netdev, "%s: Requested number of channels (%d) exceeds the maximum allowed by the XOR8 RSS hfunc (%d)\n",
512 __func__, count, xor8_max_channels);
513 goto out;
514 }
515 }
516
517 /* If RXFH is configured, changing the channels number is allowed only if
518 * it does not require resizing the RSS table. This is because the previous
519 * configuration may no longer be compatible with the new RSS table.
520 */
521 if (netif_is_rxfh_configured(priv->netdev)) {
522 int cur_rqt_size = mlx5e_rqt_size(priv->mdev, cur_params->num_channels);
523 int new_rqt_size = mlx5e_rqt_size(priv->mdev, count);
524
525 if (new_rqt_size != cur_rqt_size) {
526 err = -EINVAL;
527 netdev_err(priv->netdev,
528 "%s: RXFH is configured, block changing channels number that affects RSS table size (new: %d, current: %d)\n",
529 __func__, new_rqt_size, cur_rqt_size);
530 goto out;
531 }
532 }
533
534 /* Don't allow changing the number of channels if HTB offload is active,
535 * because the numeration of the QoS SQs will change, while per-queue
536 * qdiscs are attached.
537 */
538 if (mlx5e_selq_is_htb_enabled(&priv->selq)) {
539 err = -EINVAL;
540 netdev_err(priv->netdev, "%s: HTB offload is active, cannot change the number of channels\n",
541 __func__);
542 goto out;
543 }
544
545 /* Don't allow changing the number of channels if MQPRIO mode channel offload is active,
546 * because it defines a partition over the channels queues.
547 */
548 if (cur_params->mqprio.mode == TC_MQPRIO_MODE_CHANNEL) {
549 err = -EINVAL;
550 netdev_err(priv->netdev, "%s: MQPRIO mode channel offload is active, cannot change the number of channels\n",
551 __func__);
552 goto out;
553 }
554
555 new_params = *cur_params;
556 new_params.num_channels = count;
557
558 opened = test_bit(MLX5E_STATE_OPENED, &priv->state);
559
560 arfs_enabled = opened && mlx5e_fs_want_arfs(priv->netdev);
561 if (arfs_enabled)
562 mlx5e_arfs_disable(priv->fs);
563
564 /* Switch to new channels, set new parameters and close old ones */
565 err = mlx5e_safe_switch_params(priv, &new_params,
566 mlx5e_num_channels_changed_ctx, NULL, true);
567
568 if (arfs_enabled) {
569 int err2 = mlx5e_arfs_enable(priv->fs);
570
571 if (err2)
572 netdev_err(priv->netdev, "%s: mlx5e_arfs_enable failed: %d\n",
573 __func__, err2);
574 }
575
576 out:
577 mutex_unlock(&priv->state_lock);
578
579 return err;
580 }
581
mlx5e_set_channels(struct net_device * dev,struct ethtool_channels * ch)582 static int mlx5e_set_channels(struct net_device *dev,
583 struct ethtool_channels *ch)
584 {
585 struct mlx5e_priv *priv = netdev_priv(dev);
586
587 return mlx5e_ethtool_set_channels(priv, ch);
588 }
589
mlx5e_ethtool_get_coalesce(struct mlx5e_priv * priv,struct ethtool_coalesce * coal,struct kernel_ethtool_coalesce * kernel_coal,struct netlink_ext_ack * extack)590 int mlx5e_ethtool_get_coalesce(struct mlx5e_priv *priv,
591 struct ethtool_coalesce *coal,
592 struct kernel_ethtool_coalesce *kernel_coal,
593 struct netlink_ext_ack *extack)
594 {
595 struct dim_cq_moder *rx_moder, *tx_moder;
596
597 if (!MLX5_CAP_GEN(priv->mdev, cq_moderation)) {
598 NL_SET_ERR_MSG_MOD(extack, "CQ moderation not supported");
599 return -EOPNOTSUPP;
600 }
601
602 rx_moder = &priv->channels.params.rx_cq_moderation;
603 coal->rx_coalesce_usecs = rx_moder->usec;
604 coal->rx_max_coalesced_frames = rx_moder->pkts;
605 coal->use_adaptive_rx_coalesce = priv->channels.params.rx_dim_enabled;
606 kernel_coal->use_cqe_mode_rx = priv->channels.params.rx_moder_use_cqe_mode;
607
608 tx_moder = &priv->channels.params.tx_cq_moderation;
609 coal->tx_coalesce_usecs = tx_moder->usec;
610 coal->tx_max_coalesced_frames = tx_moder->pkts;
611 coal->use_adaptive_tx_coalesce = priv->channels.params.tx_dim_enabled;
612 kernel_coal->use_cqe_mode_tx = priv->channels.params.tx_moder_use_cqe_mode;
613
614 return 0;
615 }
616
mlx5e_get_coalesce(struct net_device * netdev,struct ethtool_coalesce * coal,struct kernel_ethtool_coalesce * kernel_coal,struct netlink_ext_ack * extack)617 static int mlx5e_get_coalesce(struct net_device *netdev,
618 struct ethtool_coalesce *coal,
619 struct kernel_ethtool_coalesce *kernel_coal,
620 struct netlink_ext_ack *extack)
621 {
622 struct mlx5e_priv *priv = netdev_priv(netdev);
623
624 return mlx5e_ethtool_get_coalesce(priv, coal, kernel_coal, extack);
625 }
626
mlx5e_ethtool_get_per_queue_coalesce(struct mlx5e_priv * priv,u32 queue,struct ethtool_coalesce * coal)627 static int mlx5e_ethtool_get_per_queue_coalesce(struct mlx5e_priv *priv, u32 queue,
628 struct ethtool_coalesce *coal)
629 {
630 struct dim_cq_moder cur_moder;
631 struct mlx5e_channels *chs;
632 struct mlx5e_channel *c;
633
634 if (!MLX5_CAP_GEN(priv->mdev, cq_moderation))
635 return -EOPNOTSUPP;
636
637 mutex_lock(&priv->state_lock);
638
639 chs = &priv->channels;
640 if (chs->num <= queue) {
641 mutex_unlock(&priv->state_lock);
642 return -EINVAL;
643 }
644
645 c = chs->c[queue];
646
647 coal->use_adaptive_rx_coalesce = !!c->rq.dim;
648 if (coal->use_adaptive_rx_coalesce) {
649 cur_moder = net_dim_get_rx_moderation(c->rq.dim->mode,
650 c->rq.dim->profile_ix);
651
652 coal->rx_coalesce_usecs = cur_moder.usec;
653 coal->rx_max_coalesced_frames = cur_moder.pkts;
654 } else {
655 coal->rx_coalesce_usecs = c->rx_cq_moder.usec;
656 coal->rx_max_coalesced_frames = c->rx_cq_moder.pkts;
657 }
658
659 coal->use_adaptive_tx_coalesce = !!c->sq[0].dim;
660 if (coal->use_adaptive_tx_coalesce) {
661 /* NOTE: Will only display DIM coalesce profile information of
662 * first channel. The current interface cannot display this
663 * information for all tc.
664 */
665 cur_moder = net_dim_get_tx_moderation(c->sq[0].dim->mode,
666 c->sq[0].dim->profile_ix);
667
668 coal->tx_coalesce_usecs = cur_moder.usec;
669 coal->tx_max_coalesced_frames = cur_moder.pkts;
670
671 } else {
672 coal->tx_coalesce_usecs = c->tx_cq_moder.usec;
673 coal->tx_max_coalesced_frames = c->tx_cq_moder.pkts;
674 }
675
676 mutex_unlock(&priv->state_lock);
677
678 return 0;
679 }
680
mlx5e_get_per_queue_coalesce(struct net_device * dev,u32 queue,struct ethtool_coalesce * coal)681 int mlx5e_get_per_queue_coalesce(struct net_device *dev, u32 queue,
682 struct ethtool_coalesce *coal)
683 {
684 struct mlx5e_priv *priv = netdev_priv(dev);
685
686 return mlx5e_ethtool_get_per_queue_coalesce(priv, queue, coal);
687 }
688
689 #define MLX5E_MAX_COAL_TIME MLX5_MAX_CQ_PERIOD
690 #define MLX5E_MAX_COAL_FRAMES MLX5_MAX_CQ_COUNT
691
692 static void
mlx5e_set_priv_channels_tx_coalesce(struct mlx5e_priv * priv,struct dim_cq_moder * moder)693 mlx5e_set_priv_channels_tx_coalesce(struct mlx5e_priv *priv, struct dim_cq_moder *moder)
694 {
695 int tc;
696 int i;
697
698 for (i = 0; i < priv->channels.num; ++i) {
699 struct mlx5e_channel *c = priv->channels.c[i];
700 struct mlx5_core_dev *mdev = c->mdev;
701 enum mlx5_cq_period_mode mode;
702
703 mode = mlx5e_cq_period_mode(moder->cq_period_mode);
704 c->tx_cq_moder = *moder;
705
706 for (tc = 0; tc < c->num_tc; tc++) {
707 mlx5e_modify_cq_moderation(mdev, &c->sq[tc].cq.mcq,
708 moder->usec, moder->pkts,
709 mode);
710 }
711 }
712 }
713
714 static void
mlx5e_set_priv_channels_rx_coalesce(struct mlx5e_priv * priv,struct dim_cq_moder * moder)715 mlx5e_set_priv_channels_rx_coalesce(struct mlx5e_priv *priv, struct dim_cq_moder *moder)
716 {
717 int i;
718
719 for (i = 0; i < priv->channels.num; ++i) {
720 struct mlx5e_channel *c = priv->channels.c[i];
721 struct mlx5_core_dev *mdev = c->mdev;
722 enum mlx5_cq_period_mode mode;
723
724 mode = mlx5e_cq_period_mode(moder->cq_period_mode);
725 c->rx_cq_moder = *moder;
726
727 mlx5e_modify_cq_moderation(mdev, &c->rq.cq.mcq, moder->usec, moder->pkts,
728 mode);
729 }
730 }
731
mlx5e_ethtool_set_coalesce(struct mlx5e_priv * priv,struct ethtool_coalesce * coal,struct kernel_ethtool_coalesce * kernel_coal,struct netlink_ext_ack * extack)732 int mlx5e_ethtool_set_coalesce(struct mlx5e_priv *priv,
733 struct ethtool_coalesce *coal,
734 struct kernel_ethtool_coalesce *kernel_coal,
735 struct netlink_ext_ack *extack)
736 {
737 struct dim_cq_moder *rx_moder, *tx_moder;
738 struct mlx5_core_dev *mdev = priv->mdev;
739 bool rx_dim_enabled, tx_dim_enabled;
740 struct mlx5e_params new_params;
741 bool reset_rx, reset_tx;
742 u8 cq_period_mode;
743 int err = 0;
744
745 if (!MLX5_CAP_GEN(mdev, cq_moderation) ||
746 !MLX5_CAP_GEN(mdev, cq_period_mode_modify)) {
747 NL_SET_ERR_MSG_MOD(extack, "CQ moderation not supported");
748 return -EOPNOTSUPP;
749 }
750
751 if (coal->tx_coalesce_usecs > MLX5E_MAX_COAL_TIME ||
752 coal->rx_coalesce_usecs > MLX5E_MAX_COAL_TIME) {
753 NL_SET_ERR_MSG_FMT_MOD(
754 extack,
755 "Max coalesce time %lu usecs, tx-usecs (%u) rx-usecs (%u)",
756 MLX5E_MAX_COAL_TIME, coal->tx_coalesce_usecs,
757 coal->rx_coalesce_usecs);
758 return -ERANGE;
759 }
760
761 if (coal->tx_max_coalesced_frames > MLX5E_MAX_COAL_FRAMES ||
762 coal->rx_max_coalesced_frames > MLX5E_MAX_COAL_FRAMES) {
763 NL_SET_ERR_MSG_FMT_MOD(
764 extack,
765 "Max coalesce frames %lu, tx-frames (%u) rx-frames (%u)",
766 MLX5E_MAX_COAL_FRAMES, coal->tx_max_coalesced_frames,
767 coal->rx_max_coalesced_frames);
768 return -ERANGE;
769 }
770
771 if ((kernel_coal->use_cqe_mode_rx || kernel_coal->use_cqe_mode_tx) &&
772 !MLX5_CAP_GEN(priv->mdev, cq_period_start_from_cqe)) {
773 NL_SET_ERR_MSG_MOD(extack, "cqe-mode-rx/tx is not supported on this device");
774 return -EOPNOTSUPP;
775 }
776
777 rx_dim_enabled = !!coal->use_adaptive_rx_coalesce;
778 tx_dim_enabled = !!coal->use_adaptive_tx_coalesce;
779
780 mutex_lock(&priv->state_lock);
781 new_params = priv->channels.params;
782
783 cq_period_mode = mlx5e_dim_cq_period_mode(kernel_coal->use_cqe_mode_rx);
784 reset_rx = mlx5e_reset_rx_channels_moderation(&priv->channels, cq_period_mode,
785 rx_dim_enabled, false);
786 MLX5E_SET_PFLAG(&new_params, MLX5E_PFLAG_RX_CQE_BASED_MODER, cq_period_mode);
787
788 cq_period_mode = mlx5e_dim_cq_period_mode(kernel_coal->use_cqe_mode_tx);
789 reset_tx = mlx5e_reset_tx_channels_moderation(&priv->channels, cq_period_mode,
790 tx_dim_enabled, false);
791 MLX5E_SET_PFLAG(&new_params, MLX5E_PFLAG_TX_CQE_BASED_MODER, cq_period_mode);
792
793 reset_rx |= rx_dim_enabled != new_params.rx_dim_enabled;
794 reset_tx |= tx_dim_enabled != new_params.tx_dim_enabled;
795
796 /* Solely used for global ethtool get coalesce */
797 rx_moder = &new_params.rx_cq_moderation;
798 new_params.rx_dim_enabled = rx_dim_enabled;
799 new_params.rx_moder_use_cqe_mode = kernel_coal->use_cqe_mode_rx;
800
801 tx_moder = &new_params.tx_cq_moderation;
802 new_params.tx_dim_enabled = tx_dim_enabled;
803 new_params.tx_moder_use_cqe_mode = kernel_coal->use_cqe_mode_tx;
804
805 if (reset_rx) {
806 mlx5e_channels_rx_change_dim(&priv->channels, false);
807 mlx5e_reset_rx_moderation(rx_moder, new_params.rx_moder_use_cqe_mode,
808 rx_dim_enabled);
809
810 mlx5e_set_priv_channels_rx_coalesce(priv, rx_moder);
811 } else if (!rx_dim_enabled) {
812 rx_moder->usec = coal->rx_coalesce_usecs;
813 rx_moder->pkts = coal->rx_max_coalesced_frames;
814
815 mlx5e_set_priv_channels_rx_coalesce(priv, rx_moder);
816 }
817
818 if (reset_tx) {
819 mlx5e_channels_tx_change_dim(&priv->channels, false);
820 mlx5e_reset_tx_moderation(tx_moder, new_params.tx_moder_use_cqe_mode,
821 tx_dim_enabled);
822
823 mlx5e_set_priv_channels_tx_coalesce(priv, tx_moder);
824 } else if (!tx_dim_enabled) {
825 tx_moder->usec = coal->tx_coalesce_usecs;
826 tx_moder->pkts = coal->tx_max_coalesced_frames;
827
828 mlx5e_set_priv_channels_tx_coalesce(priv, tx_moder);
829 }
830
831 /* DIM enable/disable Rx and Tx channels */
832 err = mlx5e_channels_rx_change_dim(&priv->channels, rx_dim_enabled);
833 if (err)
834 goto state_unlock;
835 err = mlx5e_channels_tx_change_dim(&priv->channels, tx_dim_enabled);
836 if (err)
837 goto state_unlock;
838
839 err = mlx5e_safe_switch_params(priv, &new_params, NULL, NULL, false);
840 state_unlock:
841 mutex_unlock(&priv->state_lock);
842 return err;
843 }
844
mlx5e_set_coalesce(struct net_device * netdev,struct ethtool_coalesce * coal,struct kernel_ethtool_coalesce * kernel_coal,struct netlink_ext_ack * extack)845 static int mlx5e_set_coalesce(struct net_device *netdev,
846 struct ethtool_coalesce *coal,
847 struct kernel_ethtool_coalesce *kernel_coal,
848 struct netlink_ext_ack *extack)
849 {
850 struct mlx5e_priv *priv = netdev_priv(netdev);
851
852 return mlx5e_ethtool_set_coalesce(priv, coal, kernel_coal, extack);
853 }
854
mlx5e_ethtool_set_per_queue_coalesce(struct mlx5e_priv * priv,u32 queue,struct ethtool_coalesce * coal)855 static int mlx5e_ethtool_set_per_queue_coalesce(struct mlx5e_priv *priv, u32 queue,
856 struct ethtool_coalesce *coal)
857 {
858 struct mlx5_core_dev *mdev = priv->mdev;
859 bool rx_dim_enabled, tx_dim_enabled;
860 struct mlx5e_channels *chs;
861 struct mlx5e_channel *c;
862 int err = 0;
863 int tc;
864
865 if (!MLX5_CAP_GEN(mdev, cq_moderation))
866 return -EOPNOTSUPP;
867
868 if (coal->tx_coalesce_usecs > MLX5E_MAX_COAL_TIME ||
869 coal->rx_coalesce_usecs > MLX5E_MAX_COAL_TIME) {
870 netdev_info(priv->netdev, "%s: maximum coalesce time supported is %lu usecs\n",
871 __func__, MLX5E_MAX_COAL_TIME);
872 return -ERANGE;
873 }
874
875 if (coal->tx_max_coalesced_frames > MLX5E_MAX_COAL_FRAMES ||
876 coal->rx_max_coalesced_frames > MLX5E_MAX_COAL_FRAMES) {
877 netdev_info(priv->netdev, "%s: maximum coalesced frames supported is %lu\n",
878 __func__, MLX5E_MAX_COAL_FRAMES);
879 return -ERANGE;
880 }
881
882 rx_dim_enabled = !!coal->use_adaptive_rx_coalesce;
883 tx_dim_enabled = !!coal->use_adaptive_tx_coalesce;
884
885 mutex_lock(&priv->state_lock);
886
887 chs = &priv->channels;
888 if (chs->num <= queue) {
889 mutex_unlock(&priv->state_lock);
890 return -EINVAL;
891 }
892
893 c = chs->c[queue];
894
895 err = mlx5e_dim_rx_change(&c->rq, rx_dim_enabled);
896 if (err)
897 goto state_unlock;
898
899 for (tc = 0; tc < c->num_tc; tc++) {
900 err = mlx5e_dim_tx_change(&c->sq[tc], tx_dim_enabled);
901 if (err)
902 goto state_unlock;
903 }
904
905 if (!rx_dim_enabled) {
906 c->rx_cq_moder.usec = coal->rx_coalesce_usecs;
907 c->rx_cq_moder.pkts = coal->rx_max_coalesced_frames;
908
909 mlx5_core_modify_cq_moderation(mdev, &c->rq.cq.mcq,
910 coal->rx_coalesce_usecs,
911 coal->rx_max_coalesced_frames);
912 }
913
914 if (!tx_dim_enabled) {
915 c->tx_cq_moder.usec = coal->tx_coalesce_usecs;
916 c->tx_cq_moder.pkts = coal->tx_max_coalesced_frames;
917
918 for (tc = 0; tc < c->num_tc; tc++)
919 mlx5_core_modify_cq_moderation(mdev, &c->sq[tc].cq.mcq,
920 coal->tx_coalesce_usecs,
921 coal->tx_max_coalesced_frames);
922 }
923
924 state_unlock:
925 mutex_unlock(&priv->state_lock);
926 return err;
927 }
928
mlx5e_set_per_queue_coalesce(struct net_device * dev,u32 queue,struct ethtool_coalesce * coal)929 int mlx5e_set_per_queue_coalesce(struct net_device *dev, u32 queue,
930 struct ethtool_coalesce *coal)
931 {
932 struct mlx5e_priv *priv = netdev_priv(dev);
933
934 return mlx5e_ethtool_set_per_queue_coalesce(priv, queue, coal);
935 }
936
ptys2ethtool_process_link(u32 eth_eproto,bool ext,bool advertised,unsigned long * modes)937 static void ptys2ethtool_process_link(u32 eth_eproto, bool ext, bool advertised,
938 unsigned long *modes)
939 {
940 unsigned long eproto = eth_eproto;
941 struct ptys2ethtool_config *table;
942 u32 max_size;
943 int proto;
944
945 mlx5e_ethtool_get_speed_arr(ext, &table, &max_size);
946 for_each_set_bit(proto, &eproto, max_size)
947 bitmap_or(modes, modes,
948 advertised ?
949 table[proto].advertised : table[proto].supported,
950 __ETHTOOL_LINK_MODE_MASK_NBITS);
951 }
952
953 static const u32 pplm_fec_2_ethtool[] = {
954 [MLX5E_FEC_NOFEC] = ETHTOOL_FEC_OFF,
955 [MLX5E_FEC_FIRECODE] = ETHTOOL_FEC_BASER,
956 [MLX5E_FEC_RS_528_514] = ETHTOOL_FEC_RS,
957 [MLX5E_FEC_RS_544_514] = ETHTOOL_FEC_RS,
958 [MLX5E_FEC_LLRS_272_257_1] = ETHTOOL_FEC_LLRS,
959 [MLX5E_FEC_RS_544_514_INTERLEAVED_QUAD] = ETHTOOL_FEC_RS,
960 };
961
pplm2ethtool_fec(u_long fec_mode,unsigned long size)962 static u32 pplm2ethtool_fec(u_long fec_mode, unsigned long size)
963 {
964 int mode = 0;
965
966 if (!fec_mode)
967 return ETHTOOL_FEC_AUTO;
968
969 mode = find_first_bit(&fec_mode, size);
970
971 if (mode < ARRAY_SIZE(pplm_fec_2_ethtool))
972 return pplm_fec_2_ethtool[mode];
973
974 return 0;
975 }
976
977 #define MLX5E_ADVERTISE_SUPPORTED_FEC(mlx5_fec, ethtool_fec) \
978 do { \
979 if (mlx5e_fec_in_caps(dev, 1 << (mlx5_fec))) \
980 __set_bit(ethtool_fec, \
981 link_ksettings->link_modes.supported);\
982 } while (0)
983
984 static const u32 pplm_fec_2_ethtool_linkmodes[] = {
985 [MLX5E_FEC_NOFEC] = ETHTOOL_LINK_MODE_FEC_NONE_BIT,
986 [MLX5E_FEC_FIRECODE] = ETHTOOL_LINK_MODE_FEC_BASER_BIT,
987 [MLX5E_FEC_RS_528_514] = ETHTOOL_LINK_MODE_FEC_RS_BIT,
988 [MLX5E_FEC_RS_544_514] = ETHTOOL_LINK_MODE_FEC_RS_BIT,
989 [MLX5E_FEC_LLRS_272_257_1] = ETHTOOL_LINK_MODE_FEC_LLRS_BIT,
990 };
991
get_fec_supported_advertised(struct mlx5_core_dev * dev,struct ethtool_link_ksettings * link_ksettings)992 static int get_fec_supported_advertised(struct mlx5_core_dev *dev,
993 struct ethtool_link_ksettings *link_ksettings)
994 {
995 unsigned long active_fec_long;
996 u32 active_fec;
997 u32 bitn;
998 int err;
999
1000 err = mlx5e_get_fec_mode(dev, &active_fec, NULL);
1001 if (err)
1002 return (err == -EOPNOTSUPP) ? 0 : err;
1003
1004 MLX5E_ADVERTISE_SUPPORTED_FEC(MLX5E_FEC_NOFEC,
1005 ETHTOOL_LINK_MODE_FEC_NONE_BIT);
1006 MLX5E_ADVERTISE_SUPPORTED_FEC(MLX5E_FEC_FIRECODE,
1007 ETHTOOL_LINK_MODE_FEC_BASER_BIT);
1008 MLX5E_ADVERTISE_SUPPORTED_FEC(MLX5E_FEC_RS_528_514,
1009 ETHTOOL_LINK_MODE_FEC_RS_BIT);
1010 MLX5E_ADVERTISE_SUPPORTED_FEC(MLX5E_FEC_LLRS_272_257_1,
1011 ETHTOOL_LINK_MODE_FEC_LLRS_BIT);
1012
1013 active_fec_long = active_fec;
1014 /* active fec is a bit set, find out which bit is set and
1015 * advertise the corresponding ethtool bit
1016 */
1017 bitn = find_first_bit(&active_fec_long, sizeof(active_fec_long) * BITS_PER_BYTE);
1018 if (bitn < ARRAY_SIZE(pplm_fec_2_ethtool_linkmodes))
1019 __set_bit(pplm_fec_2_ethtool_linkmodes[bitn],
1020 link_ksettings->link_modes.advertising);
1021
1022 return 0;
1023 }
1024
ptys2ethtool_supported_advertised_port(struct mlx5_core_dev * mdev,struct ethtool_link_ksettings * link_ksettings,u32 eth_proto_cap,u8 connector_type)1025 static void ptys2ethtool_supported_advertised_port(struct mlx5_core_dev *mdev,
1026 struct ethtool_link_ksettings *link_ksettings,
1027 u32 eth_proto_cap, u8 connector_type)
1028 {
1029 if (!MLX5_CAP_PCAM_FEATURE(mdev, ptys_connector_type)) {
1030 if (eth_proto_cap & (MLX5E_PROT_MASK(MLX5E_10GBASE_CR)
1031 | MLX5E_PROT_MASK(MLX5E_10GBASE_SR)
1032 | MLX5E_PROT_MASK(MLX5E_40GBASE_CR4)
1033 | MLX5E_PROT_MASK(MLX5E_40GBASE_SR4)
1034 | MLX5E_PROT_MASK(MLX5E_100GBASE_SR4)
1035 | MLX5E_PROT_MASK(MLX5E_1000BASE_CX_SGMII))) {
1036 ethtool_link_ksettings_add_link_mode(link_ksettings,
1037 supported,
1038 FIBRE);
1039 ethtool_link_ksettings_add_link_mode(link_ksettings,
1040 advertising,
1041 FIBRE);
1042 }
1043
1044 if (eth_proto_cap & (MLX5E_PROT_MASK(MLX5E_100GBASE_KR4)
1045 | MLX5E_PROT_MASK(MLX5E_40GBASE_KR4)
1046 | MLX5E_PROT_MASK(MLX5E_10GBASE_KR)
1047 | MLX5E_PROT_MASK(MLX5E_10GBASE_KX4)
1048 | MLX5E_PROT_MASK(MLX5E_1000BASE_KX))) {
1049 ethtool_link_ksettings_add_link_mode(link_ksettings,
1050 supported,
1051 Backplane);
1052 ethtool_link_ksettings_add_link_mode(link_ksettings,
1053 advertising,
1054 Backplane);
1055 }
1056 return;
1057 }
1058
1059 switch (connector_type) {
1060 case MLX5E_PORT_TP:
1061 ethtool_link_ksettings_add_link_mode(link_ksettings,
1062 supported, TP);
1063 ethtool_link_ksettings_add_link_mode(link_ksettings,
1064 advertising, TP);
1065 break;
1066 case MLX5E_PORT_AUI:
1067 ethtool_link_ksettings_add_link_mode(link_ksettings,
1068 supported, AUI);
1069 ethtool_link_ksettings_add_link_mode(link_ksettings,
1070 advertising, AUI);
1071 break;
1072 case MLX5E_PORT_BNC:
1073 ethtool_link_ksettings_add_link_mode(link_ksettings,
1074 supported, BNC);
1075 ethtool_link_ksettings_add_link_mode(link_ksettings,
1076 advertising, BNC);
1077 break;
1078 case MLX5E_PORT_MII:
1079 ethtool_link_ksettings_add_link_mode(link_ksettings,
1080 supported, MII);
1081 ethtool_link_ksettings_add_link_mode(link_ksettings,
1082 advertising, MII);
1083 break;
1084 case MLX5E_PORT_FIBRE:
1085 ethtool_link_ksettings_add_link_mode(link_ksettings,
1086 supported, FIBRE);
1087 ethtool_link_ksettings_add_link_mode(link_ksettings,
1088 advertising, FIBRE);
1089 break;
1090 case MLX5E_PORT_DA:
1091 ethtool_link_ksettings_add_link_mode(link_ksettings,
1092 supported, Backplane);
1093 ethtool_link_ksettings_add_link_mode(link_ksettings,
1094 advertising, Backplane);
1095 break;
1096 case MLX5E_PORT_NONE:
1097 case MLX5E_PORT_OTHER:
1098 default:
1099 break;
1100 }
1101 }
1102
get_link_properties(struct net_device * netdev,u32 eth_proto_oper,bool force_legacy,u16 data_rate_oper,struct ethtool_link_ksettings * link_ksettings)1103 static void get_link_properties(struct net_device *netdev,
1104 u32 eth_proto_oper, bool force_legacy,
1105 u16 data_rate_oper,
1106 struct ethtool_link_ksettings *link_ksettings)
1107 {
1108 struct mlx5e_priv *priv = netdev_priv(netdev);
1109 const struct mlx5_link_info *info;
1110 u8 duplex = DUPLEX_UNKNOWN;
1111 u32 speed = SPEED_UNKNOWN;
1112 u32 lanes = LANES_UNKNOWN;
1113
1114 if (!netif_carrier_ok(netdev))
1115 goto out;
1116
1117 info = mlx5_port_ptys2info(priv->mdev, eth_proto_oper, force_legacy);
1118 if (info) {
1119 speed = info->speed;
1120 lanes = info->lanes;
1121 duplex = DUPLEX_FULL;
1122 } else if (data_rate_oper)
1123 speed = 100 * data_rate_oper;
1124
1125 out:
1126 link_ksettings->base.duplex = duplex;
1127 link_ksettings->base.speed = speed;
1128 link_ksettings->lanes = lanes;
1129 }
1130
get_supported(struct mlx5_core_dev * mdev,u32 eth_proto_cap,struct ethtool_link_ksettings * link_ksettings)1131 static void get_supported(struct mlx5_core_dev *mdev, u32 eth_proto_cap,
1132 struct ethtool_link_ksettings *link_ksettings)
1133 {
1134 unsigned long *supported = link_ksettings->link_modes.supported;
1135 bool ext = mlx5_ptys_ext_supported(mdev);
1136
1137 ptys2ethtool_process_link(eth_proto_cap, ext, false, supported);
1138
1139 ethtool_link_ksettings_add_link_mode(link_ksettings, supported, Pause);
1140 }
1141
get_advertising(u32 eth_proto_admin,u8 tx_pause,u8 rx_pause,struct ethtool_link_ksettings * link_ksettings,bool ext)1142 static void get_advertising(u32 eth_proto_admin, u8 tx_pause, u8 rx_pause,
1143 struct ethtool_link_ksettings *link_ksettings,
1144 bool ext)
1145 {
1146 unsigned long *advertising = link_ksettings->link_modes.advertising;
1147 ptys2ethtool_process_link(eth_proto_admin, ext, true, advertising);
1148 if (rx_pause)
1149 ethtool_link_ksettings_add_link_mode(link_ksettings, advertising, Pause);
1150 if (tx_pause ^ rx_pause)
1151 ethtool_link_ksettings_add_link_mode(link_ksettings, advertising, Asym_Pause);
1152 }
1153
1154 static int ptys2connector_type[MLX5E_CONNECTOR_TYPE_NUMBER] = {
1155 [MLX5E_PORT_UNKNOWN] = PORT_OTHER,
1156 [MLX5E_PORT_NONE] = PORT_NONE,
1157 [MLX5E_PORT_TP] = PORT_TP,
1158 [MLX5E_PORT_AUI] = PORT_AUI,
1159 [MLX5E_PORT_BNC] = PORT_BNC,
1160 [MLX5E_PORT_MII] = PORT_MII,
1161 [MLX5E_PORT_FIBRE] = PORT_FIBRE,
1162 [MLX5E_PORT_DA] = PORT_DA,
1163 [MLX5E_PORT_OTHER] = PORT_OTHER,
1164 };
1165
get_connector_port(struct mlx5_core_dev * mdev,u32 eth_proto,u8 connector_type)1166 static u8 get_connector_port(struct mlx5_core_dev *mdev, u32 eth_proto, u8 connector_type)
1167 {
1168 if (MLX5_CAP_PCAM_FEATURE(mdev, ptys_connector_type))
1169 return ptys2connector_type[connector_type];
1170
1171 if (eth_proto &
1172 (MLX5E_PROT_MASK(MLX5E_10GBASE_SR) |
1173 MLX5E_PROT_MASK(MLX5E_40GBASE_SR4) |
1174 MLX5E_PROT_MASK(MLX5E_100GBASE_SR4) |
1175 MLX5E_PROT_MASK(MLX5E_1000BASE_CX_SGMII))) {
1176 return PORT_FIBRE;
1177 }
1178
1179 if (eth_proto &
1180 (MLX5E_PROT_MASK(MLX5E_40GBASE_CR4) |
1181 MLX5E_PROT_MASK(MLX5E_10GBASE_CR) |
1182 MLX5E_PROT_MASK(MLX5E_100GBASE_CR4))) {
1183 return PORT_DA;
1184 }
1185
1186 if (eth_proto &
1187 (MLX5E_PROT_MASK(MLX5E_10GBASE_KX4) |
1188 MLX5E_PROT_MASK(MLX5E_10GBASE_KR) |
1189 MLX5E_PROT_MASK(MLX5E_40GBASE_KR4) |
1190 MLX5E_PROT_MASK(MLX5E_100GBASE_KR4))) {
1191 return PORT_NONE;
1192 }
1193
1194 return PORT_OTHER;
1195 }
1196
get_lp_advertising(struct mlx5_core_dev * mdev,u32 eth_proto_lp,struct ethtool_link_ksettings * link_ksettings)1197 static void get_lp_advertising(struct mlx5_core_dev *mdev, u32 eth_proto_lp,
1198 struct ethtool_link_ksettings *link_ksettings)
1199 {
1200 unsigned long *lp_advertising = link_ksettings->link_modes.lp_advertising;
1201 bool ext = mlx5_ptys_ext_supported(mdev);
1202
1203 ptys2ethtool_process_link(eth_proto_lp, ext, true, lp_advertising);
1204 }
1205
mlx5e_ethtool_get_link_ksettings(struct mlx5e_priv * priv,struct ethtool_link_ksettings * link_ksettings)1206 static int mlx5e_ethtool_get_link_ksettings(struct mlx5e_priv *priv,
1207 struct ethtool_link_ksettings *link_ksettings)
1208 {
1209 struct mlx5_core_dev *mdev = priv->mdev;
1210 u32 out[MLX5_ST_SZ_DW(ptys_reg)] = {};
1211 u32 eth_proto_admin;
1212 u8 an_disable_admin;
1213 u16 data_rate_oper;
1214 u32 eth_proto_oper;
1215 u32 eth_proto_cap;
1216 u8 connector_type;
1217 u32 rx_pause = 0;
1218 u32 tx_pause = 0;
1219 u32 eth_proto_lp;
1220 bool admin_ext;
1221 u8 an_status;
1222 bool ext;
1223 int err;
1224
1225 err = mlx5_query_port_ptys(mdev, out, sizeof(out), MLX5_PTYS_EN, 1, 0);
1226 if (err) {
1227 netdev_err(priv->netdev, "%s: query port ptys failed: %d\n",
1228 __func__, err);
1229 goto err_query_regs;
1230 }
1231 ext = !!MLX5_GET_ETH_PROTO(ptys_reg, out, true, eth_proto_capability);
1232 eth_proto_cap = MLX5_GET_ETH_PROTO(ptys_reg, out, ext,
1233 eth_proto_capability);
1234 eth_proto_admin = MLX5_GET_ETH_PROTO(ptys_reg, out, ext,
1235 eth_proto_admin);
1236 /* Fields: eth_proto_admin and ext_eth_proto_admin are
1237 * mutually exclusive. Hence try reading legacy advertising
1238 * when extended advertising is zero.
1239 * admin_ext indicates which proto_admin (ext vs. legacy)
1240 * should be read and interpreted
1241 */
1242 admin_ext = ext;
1243 if (ext && !eth_proto_admin) {
1244 eth_proto_admin = MLX5_GET_ETH_PROTO(ptys_reg, out, false,
1245 eth_proto_admin);
1246 admin_ext = false;
1247 }
1248
1249 eth_proto_oper = MLX5_GET_ETH_PROTO(ptys_reg, out, admin_ext,
1250 eth_proto_oper);
1251 eth_proto_lp = MLX5_GET(ptys_reg, out, eth_proto_lp_advertise);
1252 an_disable_admin = MLX5_GET(ptys_reg, out, an_disable_admin);
1253 an_status = MLX5_GET(ptys_reg, out, an_status);
1254 connector_type = MLX5_GET(ptys_reg, out, connector_type);
1255 data_rate_oper = MLX5_GET(ptys_reg, out, data_rate_oper);
1256
1257 mlx5_query_port_pause(mdev, &rx_pause, &tx_pause);
1258
1259 ethtool_link_ksettings_zero_link_mode(link_ksettings, supported);
1260 ethtool_link_ksettings_zero_link_mode(link_ksettings, advertising);
1261
1262 get_supported(mdev, eth_proto_cap, link_ksettings);
1263 get_advertising(eth_proto_admin, tx_pause, rx_pause, link_ksettings,
1264 admin_ext);
1265 get_link_properties(priv->netdev, eth_proto_oper, !admin_ext,
1266 data_rate_oper, link_ksettings);
1267
1268 eth_proto_oper = eth_proto_oper ? eth_proto_oper : eth_proto_cap;
1269 connector_type = connector_type < MLX5E_CONNECTOR_TYPE_NUMBER ?
1270 connector_type : MLX5E_PORT_UNKNOWN;
1271 link_ksettings->base.port = get_connector_port(mdev, eth_proto_oper, connector_type);
1272 ptys2ethtool_supported_advertised_port(mdev, link_ksettings, eth_proto_admin,
1273 connector_type);
1274 get_lp_advertising(mdev, eth_proto_lp, link_ksettings);
1275
1276 if (an_status == MLX5_AN_COMPLETE)
1277 ethtool_link_ksettings_add_link_mode(link_ksettings,
1278 lp_advertising, Autoneg);
1279
1280 link_ksettings->base.autoneg = an_disable_admin ? AUTONEG_DISABLE :
1281 AUTONEG_ENABLE;
1282 ethtool_link_ksettings_add_link_mode(link_ksettings, supported,
1283 Autoneg);
1284
1285 err = get_fec_supported_advertised(mdev, link_ksettings);
1286 if (err) {
1287 netdev_dbg(priv->netdev, "%s: FEC caps query failed: %d\n",
1288 __func__, err);
1289 err = 0; /* don't fail caps query because of FEC error */
1290 }
1291
1292 if (!an_disable_admin)
1293 ethtool_link_ksettings_add_link_mode(link_ksettings,
1294 advertising, Autoneg);
1295
1296 err_query_regs:
1297 return err;
1298 }
1299
mlx5e_get_link_ksettings(struct net_device * netdev,struct ethtool_link_ksettings * link_ksettings)1300 static int mlx5e_get_link_ksettings(struct net_device *netdev,
1301 struct ethtool_link_ksettings *link_ksettings)
1302 {
1303 struct mlx5e_priv *priv = netdev_priv(netdev);
1304
1305 return mlx5e_ethtool_get_link_ksettings(priv, link_ksettings);
1306 }
1307
mlx5e_speed_validate(struct net_device * netdev,bool ext,const unsigned long link_modes,u8 autoneg)1308 static int mlx5e_speed_validate(struct net_device *netdev, bool ext,
1309 const unsigned long link_modes, u8 autoneg)
1310 {
1311 /* Extended link-mode has no speed limitations. */
1312 if (ext)
1313 return 0;
1314
1315 if ((link_modes & MLX5E_PROT_MASK(MLX5E_56GBASE_R4)) &&
1316 autoneg != AUTONEG_ENABLE) {
1317 netdev_err(netdev, "%s: 56G link speed requires autoneg enabled\n",
1318 __func__);
1319 return -EINVAL;
1320 }
1321 return 0;
1322 }
1323
mlx5e_ethtool2ptys_adver_link(const unsigned long * link_modes)1324 static u32 mlx5e_ethtool2ptys_adver_link(const unsigned long *link_modes)
1325 {
1326 u32 i, ptys_modes = 0;
1327
1328 for (i = 0; i < MLX5E_LINK_MODES_NUMBER; ++i) {
1329 if (bitmap_empty(ptys2legacy_ethtool_table[i].advertised,
1330 __ETHTOOL_LINK_MODE_MASK_NBITS))
1331 continue;
1332 if (bitmap_intersects(ptys2legacy_ethtool_table[i].advertised,
1333 link_modes,
1334 __ETHTOOL_LINK_MODE_MASK_NBITS))
1335 ptys_modes |= MLX5E_PROT_MASK(i);
1336 }
1337
1338 return ptys_modes;
1339 }
1340
mlx5e_ethtool2ptys_ext_adver_link(const unsigned long * link_modes)1341 static u32 mlx5e_ethtool2ptys_ext_adver_link(const unsigned long *link_modes)
1342 {
1343 u32 i, ptys_modes = 0;
1344 __ETHTOOL_DECLARE_LINK_MODE_MASK(modes);
1345
1346 for (i = 0; i < MLX5E_EXT_LINK_MODES_NUMBER; ++i) {
1347 if (bitmap_empty(ptys2ext_ethtool_table[i].advertised,
1348 __ETHTOOL_LINK_MODE_MASK_NBITS))
1349 continue;
1350 bitmap_zero(modes, __ETHTOOL_LINK_MODE_MASK_NBITS);
1351 bitmap_and(modes, ptys2ext_ethtool_table[i].advertised,
1352 link_modes, __ETHTOOL_LINK_MODE_MASK_NBITS);
1353
1354 if (bitmap_equal(modes, ptys2ext_ethtool_table[i].advertised,
1355 __ETHTOOL_LINK_MODE_MASK_NBITS))
1356 ptys_modes |= MLX5E_PROT_MASK(i);
1357 }
1358 return ptys_modes;
1359 }
1360
ext_link_mode_requested(const unsigned long * adver)1361 static bool ext_link_mode_requested(const unsigned long *adver)
1362 {
1363 #define MLX5E_MIN_PTYS_EXT_LINK_MODE_BIT ETHTOOL_LINK_MODE_50000baseKR_Full_BIT
1364 int size = __ETHTOOL_LINK_MODE_MASK_NBITS - MLX5E_MIN_PTYS_EXT_LINK_MODE_BIT;
1365 __ETHTOOL_DECLARE_LINK_MODE_MASK(modes) = {0,};
1366
1367 bitmap_set(modes, MLX5E_MIN_PTYS_EXT_LINK_MODE_BIT, size);
1368 return bitmap_intersects(modes, adver, __ETHTOOL_LINK_MODE_MASK_NBITS);
1369 }
1370
mlx5e_ethtool_set_link_ksettings(struct mlx5e_priv * priv,const struct ethtool_link_ksettings * link_ksettings)1371 static int mlx5e_ethtool_set_link_ksettings(struct mlx5e_priv *priv,
1372 const struct ethtool_link_ksettings *link_ksettings)
1373 {
1374 struct mlx5_core_dev *mdev = priv->mdev;
1375 struct mlx5_port_eth_proto eproto;
1376 struct mlx5_link_info info = {};
1377 const unsigned long *adver;
1378 bool an_changes = false;
1379 u8 an_disable_admin;
1380 bool ext_supported;
1381 bool ext_requested;
1382 u8 an_disable_cap;
1383 bool an_disable;
1384 u32 link_modes;
1385 u8 an_status;
1386 u8 autoneg;
1387 bool ext;
1388 int err;
1389
1390 u32 (*ethtool2ptys_adver_func)(const unsigned long *adver);
1391
1392 adver = link_ksettings->link_modes.advertising;
1393 autoneg = link_ksettings->base.autoneg;
1394 info.speed = link_ksettings->base.speed;
1395 info.lanes = link_ksettings->lanes;
1396
1397 ext_supported = mlx5_ptys_ext_supported(mdev);
1398 ext_requested = ext_link_mode_requested(adver);
1399 if (!ext_supported && ext_requested)
1400 return -EOPNOTSUPP;
1401
1402 ext = autoneg == AUTONEG_ENABLE ? ext_requested : ext_supported;
1403 ethtool2ptys_adver_func = ext ? mlx5e_ethtool2ptys_ext_adver_link :
1404 mlx5e_ethtool2ptys_adver_link;
1405 err = mlx5_port_query_eth_proto(mdev, 1, ext, &eproto);
1406 if (err) {
1407 netdev_err(priv->netdev, "%s: query port eth proto failed: %d\n",
1408 __func__, err);
1409 goto out;
1410 }
1411 link_modes = autoneg == AUTONEG_ENABLE ? ethtool2ptys_adver_func(adver) :
1412 mlx5_port_info2linkmodes(mdev, &info, !ext);
1413
1414 err = mlx5e_speed_validate(priv->netdev, ext, link_modes, autoneg);
1415 if (err)
1416 goto out;
1417
1418 link_modes = link_modes & eproto.cap;
1419 if (!link_modes) {
1420 netdev_err(priv->netdev, "%s: Not supported link mode(s) requested",
1421 __func__);
1422 err = -EINVAL;
1423 goto out;
1424 }
1425
1426 mlx5_port_query_eth_autoneg(mdev, &an_status, &an_disable_cap,
1427 &an_disable_admin);
1428
1429 an_disable = autoneg == AUTONEG_DISABLE;
1430 an_changes = ((!an_disable && an_disable_admin) ||
1431 (an_disable && !an_disable_admin));
1432
1433 if (!an_changes && link_modes == eproto.admin)
1434 goto out;
1435
1436 err = mlx5_port_set_eth_ptys(mdev, an_disable, link_modes, ext);
1437 if (err) {
1438 netdev_err(priv->netdev, "%s: failed to set ptys reg: %d\n", __func__, err);
1439 goto out;
1440 }
1441
1442 mlx5_toggle_port_link(mdev);
1443
1444 out:
1445 return err;
1446 }
1447
mlx5e_set_link_ksettings(struct net_device * netdev,const struct ethtool_link_ksettings * link_ksettings)1448 static int mlx5e_set_link_ksettings(struct net_device *netdev,
1449 const struct ethtool_link_ksettings *link_ksettings)
1450 {
1451 struct mlx5e_priv *priv = netdev_priv(netdev);
1452
1453 return mlx5e_ethtool_set_link_ksettings(priv, link_ksettings);
1454 }
1455
mlx5e_ethtool_get_rxfh_key_size(struct mlx5e_priv * priv)1456 u32 mlx5e_ethtool_get_rxfh_key_size(struct mlx5e_priv *priv)
1457 {
1458 return sizeof_field(struct mlx5e_rss_params_hash, toeplitz_hash_key);
1459 }
1460
mlx5e_get_rxfh_key_size(struct net_device * netdev)1461 static u32 mlx5e_get_rxfh_key_size(struct net_device *netdev)
1462 {
1463 struct mlx5e_priv *priv = netdev_priv(netdev);
1464
1465 return mlx5e_ethtool_get_rxfh_key_size(priv);
1466 }
1467
mlx5e_ethtool_get_rxfh_indir_size(struct mlx5e_priv * priv)1468 u32 mlx5e_ethtool_get_rxfh_indir_size(struct mlx5e_priv *priv)
1469 {
1470 return mlx5e_rqt_size(priv->mdev, priv->channels.params.num_channels);
1471 }
1472
mlx5e_get_rxfh_indir_size(struct net_device * netdev)1473 static u32 mlx5e_get_rxfh_indir_size(struct net_device *netdev)
1474 {
1475 struct mlx5e_priv *priv = netdev_priv(netdev);
1476
1477 return mlx5e_ethtool_get_rxfh_indir_size(priv);
1478 }
1479
mlx5e_get_rxfh(struct net_device * netdev,struct ethtool_rxfh_param * rxfh)1480 static int mlx5e_get_rxfh(struct net_device *netdev, struct ethtool_rxfh_param *rxfh)
1481 {
1482 struct mlx5e_priv *priv = netdev_priv(netdev);
1483 bool symmetric;
1484
1485 mutex_lock(&priv->state_lock);
1486 mlx5e_rx_res_rss_get_rxfh(priv->rx_res, 0, rxfh->indir, rxfh->key,
1487 &rxfh->hfunc, &symmetric);
1488 mutex_unlock(&priv->state_lock);
1489
1490 if (symmetric)
1491 rxfh->input_xfrm = RXH_XFRM_SYM_OR_XOR;
1492
1493 return 0;
1494 }
1495
mlx5e_rxfh_hfunc_check(struct mlx5e_priv * priv,const struct ethtool_rxfh_param * rxfh)1496 static int mlx5e_rxfh_hfunc_check(struct mlx5e_priv *priv,
1497 const struct ethtool_rxfh_param *rxfh)
1498 {
1499 unsigned int count;
1500
1501 count = priv->channels.params.num_channels;
1502
1503 if (rxfh->hfunc == ETH_RSS_HASH_XOR) {
1504 unsigned int xor8_max_channels = mlx5e_rqt_max_num_channels_allowed_for_xor8();
1505
1506 if (count > xor8_max_channels) {
1507 netdev_err(priv->netdev, "%s: Cannot set RSS hash function to XOR, current number of channels (%d) exceeds the maximum allowed for XOR8 RSS hfunc (%d)\n",
1508 __func__, count, xor8_max_channels);
1509 return -EINVAL;
1510 }
1511 }
1512
1513 return 0;
1514 }
1515
mlx5e_set_rxfh(struct net_device * dev,struct ethtool_rxfh_param * rxfh,struct netlink_ext_ack * extack)1516 static int mlx5e_set_rxfh(struct net_device *dev,
1517 struct ethtool_rxfh_param *rxfh,
1518 struct netlink_ext_ack *extack)
1519 {
1520 bool symmetric = rxfh->input_xfrm == RXH_XFRM_SYM_OR_XOR;
1521 struct mlx5e_priv *priv = netdev_priv(dev);
1522 u8 hfunc = rxfh->hfunc;
1523 int err;
1524
1525 mutex_lock(&priv->state_lock);
1526
1527 err = mlx5e_rxfh_hfunc_check(priv, rxfh);
1528 if (err)
1529 goto unlock;
1530
1531 err = mlx5e_rx_res_rss_set_rxfh(priv->rx_res, rxfh->rss_context,
1532 rxfh->indir, rxfh->key,
1533 hfunc == ETH_RSS_HASH_NO_CHANGE ? NULL : &hfunc,
1534 rxfh->input_xfrm == RXH_XFRM_NO_CHANGE ? NULL : &symmetric);
1535
1536 unlock:
1537 mutex_unlock(&priv->state_lock);
1538 return err;
1539 }
1540
mlx5e_create_rxfh_context(struct net_device * dev,struct ethtool_rxfh_context * ctx,const struct ethtool_rxfh_param * rxfh,struct netlink_ext_ack * extack)1541 static int mlx5e_create_rxfh_context(struct net_device *dev,
1542 struct ethtool_rxfh_context *ctx,
1543 const struct ethtool_rxfh_param *rxfh,
1544 struct netlink_ext_ack *extack)
1545 {
1546 bool symmetric = rxfh->input_xfrm == RXH_XFRM_SYM_OR_XOR;
1547 struct mlx5e_priv *priv = netdev_priv(dev);
1548 u8 hfunc = rxfh->hfunc;
1549 int err;
1550
1551 mutex_lock(&priv->state_lock);
1552
1553 err = mlx5e_rxfh_hfunc_check(priv, rxfh);
1554 if (err)
1555 goto unlock;
1556
1557 err = mlx5e_rx_res_rss_init(priv->rx_res, rxfh->rss_context,
1558 priv->channels.params.num_channels);
1559 if (err)
1560 goto unlock;
1561
1562 err = mlx5e_rx_res_rss_set_rxfh(priv->rx_res, rxfh->rss_context,
1563 rxfh->indir, rxfh->key,
1564 hfunc == ETH_RSS_HASH_NO_CHANGE ? NULL : &hfunc,
1565 rxfh->input_xfrm == RXH_XFRM_NO_CHANGE ? NULL : &symmetric);
1566 if (err)
1567 goto unlock;
1568
1569 mlx5e_rx_res_rss_get_rxfh(priv->rx_res, rxfh->rss_context,
1570 ethtool_rxfh_context_indir(ctx),
1571 ethtool_rxfh_context_key(ctx),
1572 &ctx->hfunc, &symmetric);
1573 if (symmetric)
1574 ctx->input_xfrm = RXH_XFRM_SYM_OR_XOR;
1575
1576 unlock:
1577 mutex_unlock(&priv->state_lock);
1578 return err;
1579 }
1580
mlx5e_modify_rxfh_context(struct net_device * dev,struct ethtool_rxfh_context * ctx,const struct ethtool_rxfh_param * rxfh,struct netlink_ext_ack * extack)1581 static int mlx5e_modify_rxfh_context(struct net_device *dev,
1582 struct ethtool_rxfh_context *ctx,
1583 const struct ethtool_rxfh_param *rxfh,
1584 struct netlink_ext_ack *extack)
1585 {
1586 bool symmetric = rxfh->input_xfrm == RXH_XFRM_SYM_OR_XOR;
1587 struct mlx5e_priv *priv = netdev_priv(dev);
1588 u8 hfunc = rxfh->hfunc;
1589 int err;
1590
1591 mutex_lock(&priv->state_lock);
1592
1593 err = mlx5e_rxfh_hfunc_check(priv, rxfh);
1594 if (err)
1595 goto unlock;
1596
1597 err = mlx5e_rx_res_rss_set_rxfh(priv->rx_res, rxfh->rss_context,
1598 rxfh->indir, rxfh->key,
1599 hfunc == ETH_RSS_HASH_NO_CHANGE ? NULL : &hfunc,
1600 rxfh->input_xfrm == RXH_XFRM_NO_CHANGE ? NULL : &symmetric);
1601
1602 unlock:
1603 mutex_unlock(&priv->state_lock);
1604 return err;
1605 }
1606
mlx5e_remove_rxfh_context(struct net_device * dev,struct ethtool_rxfh_context * ctx,u32 rss_context,struct netlink_ext_ack * extack)1607 static int mlx5e_remove_rxfh_context(struct net_device *dev,
1608 struct ethtool_rxfh_context *ctx,
1609 u32 rss_context,
1610 struct netlink_ext_ack *extack)
1611 {
1612 struct mlx5e_priv *priv = netdev_priv(dev);
1613 int err;
1614
1615 mutex_lock(&priv->state_lock);
1616 err = mlx5e_rx_res_rss_destroy(priv->rx_res, rss_context);
1617 mutex_unlock(&priv->state_lock);
1618 return err;
1619 }
1620
1621 #define MLX5E_PFC_PREVEN_AUTO_TOUT_MSEC 100
1622 #define MLX5E_PFC_PREVEN_TOUT_MAX_MSEC 8000
1623 #define MLX5E_PFC_PREVEN_MINOR_PRECENT 85
1624 #define MLX5E_PFC_PREVEN_TOUT_MIN_MSEC 80
1625 #define MLX5E_DEVICE_STALL_MINOR_WATERMARK(critical_tout) \
1626 max_t(u16, MLX5E_PFC_PREVEN_TOUT_MIN_MSEC, \
1627 (critical_tout * MLX5E_PFC_PREVEN_MINOR_PRECENT) / 100)
1628
mlx5e_get_pfc_prevention_tout(struct net_device * netdev,u16 * pfc_prevention_tout)1629 static int mlx5e_get_pfc_prevention_tout(struct net_device *netdev,
1630 u16 *pfc_prevention_tout)
1631 {
1632 struct mlx5e_priv *priv = netdev_priv(netdev);
1633 struct mlx5_core_dev *mdev = priv->mdev;
1634
1635 if (!MLX5_CAP_PCAM_FEATURE((priv)->mdev, pfcc_mask) ||
1636 !MLX5_CAP_DEBUG((priv)->mdev, stall_detect))
1637 return -EOPNOTSUPP;
1638
1639 return mlx5_query_port_stall_watermark(mdev, pfc_prevention_tout, NULL);
1640 }
1641
mlx5e_set_pfc_prevention_tout(struct net_device * netdev,u16 pfc_preven)1642 static int mlx5e_set_pfc_prevention_tout(struct net_device *netdev,
1643 u16 pfc_preven)
1644 {
1645 struct mlx5e_priv *priv = netdev_priv(netdev);
1646 struct mlx5_core_dev *mdev = priv->mdev;
1647 u16 critical_tout;
1648 u16 minor;
1649
1650 if (!MLX5_CAP_PCAM_FEATURE((priv)->mdev, pfcc_mask) ||
1651 !MLX5_CAP_DEBUG((priv)->mdev, stall_detect))
1652 return -EOPNOTSUPP;
1653
1654 critical_tout = (pfc_preven == PFC_STORM_PREVENTION_AUTO) ?
1655 MLX5E_PFC_PREVEN_AUTO_TOUT_MSEC :
1656 pfc_preven;
1657
1658 if (critical_tout != PFC_STORM_PREVENTION_DISABLE &&
1659 (critical_tout > MLX5E_PFC_PREVEN_TOUT_MAX_MSEC ||
1660 critical_tout < MLX5E_PFC_PREVEN_TOUT_MIN_MSEC)) {
1661 netdev_info(netdev, "%s: pfc prevention tout not in range (%d-%d)\n",
1662 __func__, MLX5E_PFC_PREVEN_TOUT_MIN_MSEC,
1663 MLX5E_PFC_PREVEN_TOUT_MAX_MSEC);
1664 return -EINVAL;
1665 }
1666
1667 minor = MLX5E_DEVICE_STALL_MINOR_WATERMARK(critical_tout);
1668 return mlx5_set_port_stall_watermark(mdev, critical_tout,
1669 minor);
1670 }
1671
mlx5e_get_tunable(struct net_device * dev,const struct ethtool_tunable * tuna,void * data)1672 static int mlx5e_get_tunable(struct net_device *dev,
1673 const struct ethtool_tunable *tuna,
1674 void *data)
1675 {
1676 int err;
1677
1678 switch (tuna->id) {
1679 case ETHTOOL_PFC_PREVENTION_TOUT:
1680 err = mlx5e_get_pfc_prevention_tout(dev, data);
1681 break;
1682 default:
1683 err = -EINVAL;
1684 break;
1685 }
1686
1687 return err;
1688 }
1689
mlx5e_set_tunable(struct net_device * dev,const struct ethtool_tunable * tuna,const void * data)1690 static int mlx5e_set_tunable(struct net_device *dev,
1691 const struct ethtool_tunable *tuna,
1692 const void *data)
1693 {
1694 struct mlx5e_priv *priv = netdev_priv(dev);
1695 int err;
1696
1697 mutex_lock(&priv->state_lock);
1698
1699 switch (tuna->id) {
1700 case ETHTOOL_PFC_PREVENTION_TOUT:
1701 err = mlx5e_set_pfc_prevention_tout(dev, *(u16 *)data);
1702 break;
1703 default:
1704 err = -EINVAL;
1705 break;
1706 }
1707
1708 mutex_unlock(&priv->state_lock);
1709 return err;
1710 }
1711
mlx5e_get_pause_stats(struct net_device * netdev,struct ethtool_pause_stats * pause_stats)1712 static void mlx5e_get_pause_stats(struct net_device *netdev,
1713 struct ethtool_pause_stats *pause_stats)
1714 {
1715 struct mlx5e_priv *priv = netdev_priv(netdev);
1716
1717 mlx5e_stats_pause_get(priv, pause_stats);
1718 }
1719
mlx5e_ethtool_get_pauseparam(struct mlx5e_priv * priv,struct ethtool_pauseparam * pauseparam)1720 static void mlx5e_ethtool_get_pauseparam(struct mlx5e_priv *priv,
1721 struct ethtool_pauseparam *pauseparam)
1722 {
1723 struct mlx5_core_dev *mdev = priv->mdev;
1724 int err;
1725
1726 err = mlx5_query_port_pause(mdev, &pauseparam->rx_pause,
1727 &pauseparam->tx_pause);
1728 if (err) {
1729 netdev_err(priv->netdev, "%s: mlx5_query_port_pause failed:0x%x\n",
1730 __func__, err);
1731 }
1732 }
1733
mlx5e_get_pauseparam(struct net_device * netdev,struct ethtool_pauseparam * pauseparam)1734 static void mlx5e_get_pauseparam(struct net_device *netdev,
1735 struct ethtool_pauseparam *pauseparam)
1736 {
1737 struct mlx5e_priv *priv = netdev_priv(netdev);
1738
1739 mlx5e_ethtool_get_pauseparam(priv, pauseparam);
1740 }
1741
mlx5e_ethtool_set_pauseparam(struct mlx5e_priv * priv,struct ethtool_pauseparam * pauseparam)1742 static int mlx5e_ethtool_set_pauseparam(struct mlx5e_priv *priv,
1743 struct ethtool_pauseparam *pauseparam)
1744 {
1745 struct mlx5_core_dev *mdev = priv->mdev;
1746 int err;
1747
1748 if (!MLX5_CAP_GEN(mdev, vport_group_manager))
1749 return -EOPNOTSUPP;
1750
1751 if (pauseparam->autoneg)
1752 return -EINVAL;
1753
1754 err = mlx5_set_port_pause(mdev,
1755 pauseparam->rx_pause ? 1 : 0,
1756 pauseparam->tx_pause ? 1 : 0);
1757 if (err) {
1758 netdev_err(priv->netdev, "%s: mlx5_set_port_pause failed:0x%x\n",
1759 __func__, err);
1760 }
1761
1762 return err;
1763 }
1764
mlx5e_set_pauseparam(struct net_device * netdev,struct ethtool_pauseparam * pauseparam)1765 static int mlx5e_set_pauseparam(struct net_device *netdev,
1766 struct ethtool_pauseparam *pauseparam)
1767 {
1768 struct mlx5e_priv *priv = netdev_priv(netdev);
1769
1770 return mlx5e_ethtool_set_pauseparam(priv, pauseparam);
1771 }
1772
mlx5e_ethtool_get_ts_info(struct mlx5e_priv * priv,struct kernel_ethtool_ts_info * info)1773 int mlx5e_ethtool_get_ts_info(struct mlx5e_priv *priv,
1774 struct kernel_ethtool_ts_info *info)
1775 {
1776 struct mlx5_core_dev *mdev = priv->mdev;
1777
1778 info->phc_index = mlx5_clock_get_ptp_index(mdev);
1779
1780 if (!MLX5_CAP_GEN(priv->mdev, device_frequency_khz) ||
1781 info->phc_index == -1)
1782 return 0;
1783
1784 info->so_timestamping = SOF_TIMESTAMPING_TX_HARDWARE |
1785 SOF_TIMESTAMPING_TX_SOFTWARE |
1786 SOF_TIMESTAMPING_RX_HARDWARE |
1787 SOF_TIMESTAMPING_RAW_HARDWARE;
1788
1789 info->tx_types = BIT(HWTSTAMP_TX_OFF) |
1790 BIT(HWTSTAMP_TX_ON);
1791
1792 info->rx_filters = BIT(HWTSTAMP_FILTER_NONE) |
1793 BIT(HWTSTAMP_FILTER_ALL);
1794
1795 return 0;
1796 }
1797
mlx5e_get_ts_info(struct net_device * dev,struct kernel_ethtool_ts_info * info)1798 static int mlx5e_get_ts_info(struct net_device *dev,
1799 struct kernel_ethtool_ts_info *info)
1800 {
1801 struct mlx5e_priv *priv = netdev_priv(dev);
1802
1803 return mlx5e_ethtool_get_ts_info(priv, info);
1804 }
1805
mlx5e_get_wol_supported(struct mlx5_core_dev * mdev)1806 static __u32 mlx5e_get_wol_supported(struct mlx5_core_dev *mdev)
1807 {
1808 __u32 ret = 0;
1809
1810 if (MLX5_CAP_GEN(mdev, wol_g))
1811 ret |= WAKE_MAGIC;
1812
1813 if (MLX5_CAP_GEN(mdev, wol_s))
1814 ret |= WAKE_MAGICSECURE;
1815
1816 if (MLX5_CAP_GEN(mdev, wol_a))
1817 ret |= WAKE_ARP;
1818
1819 if (MLX5_CAP_GEN(mdev, wol_b))
1820 ret |= WAKE_BCAST;
1821
1822 if (MLX5_CAP_GEN(mdev, wol_m))
1823 ret |= WAKE_MCAST;
1824
1825 if (MLX5_CAP_GEN(mdev, wol_u))
1826 ret |= WAKE_UCAST;
1827
1828 if (MLX5_CAP_GEN(mdev, wol_p))
1829 ret |= WAKE_PHY;
1830
1831 return ret;
1832 }
1833
mlx5e_reformat_wol_mode_mlx5_to_linux(u8 mode)1834 static __u32 mlx5e_reformat_wol_mode_mlx5_to_linux(u8 mode)
1835 {
1836 __u32 ret = 0;
1837
1838 if (mode & MLX5_WOL_MAGIC)
1839 ret |= WAKE_MAGIC;
1840
1841 if (mode & MLX5_WOL_SECURED_MAGIC)
1842 ret |= WAKE_MAGICSECURE;
1843
1844 if (mode & MLX5_WOL_ARP)
1845 ret |= WAKE_ARP;
1846
1847 if (mode & MLX5_WOL_BROADCAST)
1848 ret |= WAKE_BCAST;
1849
1850 if (mode & MLX5_WOL_MULTICAST)
1851 ret |= WAKE_MCAST;
1852
1853 if (mode & MLX5_WOL_UNICAST)
1854 ret |= WAKE_UCAST;
1855
1856 if (mode & MLX5_WOL_PHY_ACTIVITY)
1857 ret |= WAKE_PHY;
1858
1859 return ret;
1860 }
1861
mlx5e_reformat_wol_mode_linux_to_mlx5(__u32 mode)1862 static u8 mlx5e_reformat_wol_mode_linux_to_mlx5(__u32 mode)
1863 {
1864 u8 ret = 0;
1865
1866 if (mode & WAKE_MAGIC)
1867 ret |= MLX5_WOL_MAGIC;
1868
1869 if (mode & WAKE_MAGICSECURE)
1870 ret |= MLX5_WOL_SECURED_MAGIC;
1871
1872 if (mode & WAKE_ARP)
1873 ret |= MLX5_WOL_ARP;
1874
1875 if (mode & WAKE_BCAST)
1876 ret |= MLX5_WOL_BROADCAST;
1877
1878 if (mode & WAKE_MCAST)
1879 ret |= MLX5_WOL_MULTICAST;
1880
1881 if (mode & WAKE_UCAST)
1882 ret |= MLX5_WOL_UNICAST;
1883
1884 if (mode & WAKE_PHY)
1885 ret |= MLX5_WOL_PHY_ACTIVITY;
1886
1887 return ret;
1888 }
1889
mlx5e_get_wol(struct net_device * netdev,struct ethtool_wolinfo * wol)1890 static void mlx5e_get_wol(struct net_device *netdev,
1891 struct ethtool_wolinfo *wol)
1892 {
1893 struct mlx5e_priv *priv = netdev_priv(netdev);
1894 struct mlx5_core_dev *mdev = priv->mdev;
1895 u8 mlx5_wol_mode;
1896 int err;
1897
1898 memset(wol, 0, sizeof(*wol));
1899
1900 wol->supported = mlx5e_get_wol_supported(mdev);
1901 if (!wol->supported)
1902 return;
1903
1904 err = mlx5_query_port_wol(mdev, &mlx5_wol_mode);
1905 if (err)
1906 return;
1907
1908 wol->wolopts = mlx5e_reformat_wol_mode_mlx5_to_linux(mlx5_wol_mode);
1909 }
1910
mlx5e_set_wol(struct net_device * netdev,struct ethtool_wolinfo * wol)1911 static int mlx5e_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
1912 {
1913 struct mlx5e_priv *priv = netdev_priv(netdev);
1914 struct mlx5_core_dev *mdev = priv->mdev;
1915 __u32 wol_supported = mlx5e_get_wol_supported(mdev);
1916 u32 mlx5_wol_mode;
1917
1918 if (!wol_supported)
1919 return -EOPNOTSUPP;
1920
1921 if (wol->wolopts & ~wol_supported)
1922 return -EINVAL;
1923
1924 mlx5_wol_mode = mlx5e_reformat_wol_mode_linux_to_mlx5(wol->wolopts);
1925
1926 return mlx5_set_port_wol(mdev, mlx5_wol_mode);
1927 }
1928
mlx5e_get_fec_stats(struct net_device * netdev,struct ethtool_fec_stats * fec_stats)1929 static void mlx5e_get_fec_stats(struct net_device *netdev,
1930 struct ethtool_fec_stats *fec_stats)
1931 {
1932 struct mlx5e_priv *priv = netdev_priv(netdev);
1933
1934 mlx5e_stats_fec_get(priv, fec_stats);
1935 }
1936
mlx5e_get_fecparam(struct net_device * netdev,struct ethtool_fecparam * fecparam)1937 static int mlx5e_get_fecparam(struct net_device *netdev,
1938 struct ethtool_fecparam *fecparam)
1939 {
1940 struct mlx5e_priv *priv = netdev_priv(netdev);
1941 struct mlx5_core_dev *mdev = priv->mdev;
1942 u16 fec_configured;
1943 u32 fec_active;
1944 int err;
1945
1946 err = mlx5e_get_fec_mode(mdev, &fec_active, &fec_configured);
1947
1948 if (err)
1949 return err;
1950
1951 fecparam->active_fec = pplm2ethtool_fec((unsigned long)fec_active,
1952 sizeof(unsigned long) * BITS_PER_BYTE);
1953
1954 if (!fecparam->active_fec)
1955 return -EOPNOTSUPP;
1956
1957 fecparam->fec = pplm2ethtool_fec((unsigned long)fec_configured,
1958 sizeof(unsigned long) * BITS_PER_BYTE);
1959
1960 return 0;
1961 }
1962
mlx5e_set_fecparam(struct net_device * netdev,struct ethtool_fecparam * fecparam)1963 static int mlx5e_set_fecparam(struct net_device *netdev,
1964 struct ethtool_fecparam *fecparam)
1965 {
1966 struct mlx5e_priv *priv = netdev_priv(netdev);
1967 struct mlx5_core_dev *mdev = priv->mdev;
1968 unsigned long fec_bitmap;
1969 u16 fec_policy = 0;
1970 int mode;
1971 int err;
1972
1973 bitmap_from_arr32(&fec_bitmap, &fecparam->fec, sizeof(fecparam->fec) * BITS_PER_BYTE);
1974 if (bitmap_weight(&fec_bitmap, ETHTOOL_FEC_LLRS_BIT + 1) > 1)
1975 return -EOPNOTSUPP;
1976
1977 for (mode = 0; mode < ARRAY_SIZE(pplm_fec_2_ethtool); mode++) {
1978 if (!(pplm_fec_2_ethtool[mode] & fecparam->fec))
1979 continue;
1980 fec_policy |= (1 << mode);
1981 break;
1982 }
1983
1984 err = mlx5e_set_fec_mode(mdev, fec_policy);
1985
1986 if (err)
1987 return err;
1988
1989 mlx5_toggle_port_link(mdev);
1990
1991 return 0;
1992 }
1993
mlx5e_set_phys_id(struct net_device * dev,enum ethtool_phys_id_state state)1994 static int mlx5e_set_phys_id(struct net_device *dev,
1995 enum ethtool_phys_id_state state)
1996 {
1997 struct mlx5e_priv *priv = netdev_priv(dev);
1998 struct mlx5_core_dev *mdev = priv->mdev;
1999 u16 beacon_duration;
2000
2001 if (!MLX5_CAP_GEN(mdev, beacon_led))
2002 return -EOPNOTSUPP;
2003
2004 switch (state) {
2005 case ETHTOOL_ID_ACTIVE:
2006 beacon_duration = MLX5_BEACON_DURATION_INF;
2007 break;
2008 case ETHTOOL_ID_INACTIVE:
2009 beacon_duration = MLX5_BEACON_DURATION_OFF;
2010 break;
2011 default:
2012 return -EOPNOTSUPP;
2013 }
2014
2015 return mlx5_set_port_beacon(mdev, beacon_duration);
2016 }
2017
mlx5e_get_module_info(struct net_device * netdev,struct ethtool_modinfo * modinfo)2018 static int mlx5e_get_module_info(struct net_device *netdev,
2019 struct ethtool_modinfo *modinfo)
2020 {
2021 struct mlx5e_priv *priv = netdev_priv(netdev);
2022 struct mlx5_core_dev *dev = priv->mdev;
2023 int size_read = 0;
2024 u8 data[4] = {0};
2025
2026 size_read = mlx5_query_module_eeprom(dev, 0, 2, data);
2027 if (size_read < 2)
2028 return -EIO;
2029
2030 /* data[0] = identifier byte */
2031 switch (data[0]) {
2032 case MLX5_MODULE_ID_QSFP:
2033 modinfo->type = ETH_MODULE_SFF_8436;
2034 modinfo->eeprom_len = ETH_MODULE_SFF_8436_MAX_LEN;
2035 break;
2036 case MLX5_MODULE_ID_QSFP_PLUS:
2037 case MLX5_MODULE_ID_QSFP28:
2038 /* data[1] = revision id */
2039 if (data[0] == MLX5_MODULE_ID_QSFP28 || data[1] >= 0x3) {
2040 modinfo->type = ETH_MODULE_SFF_8636;
2041 modinfo->eeprom_len = ETH_MODULE_SFF_8636_MAX_LEN;
2042 } else {
2043 modinfo->type = ETH_MODULE_SFF_8436;
2044 modinfo->eeprom_len = ETH_MODULE_SFF_8436_MAX_LEN;
2045 }
2046 break;
2047 case MLX5_MODULE_ID_SFP:
2048 modinfo->type = ETH_MODULE_SFF_8472;
2049 modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;
2050 break;
2051 default:
2052 netdev_err(priv->netdev, "%s: cable type not recognized:0x%x\n",
2053 __func__, data[0]);
2054 return -EINVAL;
2055 }
2056
2057 return 0;
2058 }
2059
mlx5e_get_module_eeprom(struct net_device * netdev,struct ethtool_eeprom * ee,u8 * data)2060 static int mlx5e_get_module_eeprom(struct net_device *netdev,
2061 struct ethtool_eeprom *ee,
2062 u8 *data)
2063 {
2064 struct mlx5e_priv *priv = netdev_priv(netdev);
2065 struct mlx5_core_dev *mdev = priv->mdev;
2066 int offset = ee->offset;
2067 int size_read;
2068 int i = 0;
2069
2070 if (!ee->len)
2071 return -EINVAL;
2072
2073 memset(data, 0, ee->len);
2074
2075 while (i < ee->len) {
2076 size_read = mlx5_query_module_eeprom(mdev, offset, ee->len - i,
2077 data + i);
2078
2079 if (!size_read)
2080 /* Done reading */
2081 return 0;
2082
2083 if (size_read < 0) {
2084 netdev_err(priv->netdev, "%s: mlx5_query_eeprom failed:0x%x\n",
2085 __func__, size_read);
2086 return size_read;
2087 }
2088
2089 i += size_read;
2090 offset += size_read;
2091 }
2092
2093 return 0;
2094 }
2095
mlx5e_get_module_eeprom_by_page(struct net_device * netdev,const struct ethtool_module_eeprom * page_data,struct netlink_ext_ack * extack)2096 static int mlx5e_get_module_eeprom_by_page(struct net_device *netdev,
2097 const struct ethtool_module_eeprom *page_data,
2098 struct netlink_ext_ack *extack)
2099 {
2100 struct mlx5e_priv *priv = netdev_priv(netdev);
2101 struct mlx5_module_eeprom_query_params query;
2102 struct mlx5_core_dev *mdev = priv->mdev;
2103 u8 *data = page_data->data;
2104 int size_read;
2105 int i = 0;
2106
2107 if (!page_data->length)
2108 return -EINVAL;
2109
2110 memset(data, 0, page_data->length);
2111
2112 query.offset = page_data->offset;
2113 query.i2c_address = page_data->i2c_address;
2114 query.bank = page_data->bank;
2115 query.page = page_data->page;
2116 while (i < page_data->length) {
2117 query.size = page_data->length - i;
2118 size_read = mlx5_query_module_eeprom_by_page(mdev, &query, data + i);
2119
2120 /* Done reading, return how many bytes was read */
2121 if (!size_read)
2122 return i;
2123
2124 if (size_read == -EINVAL)
2125 return -EINVAL;
2126 if (size_read < 0) {
2127 NL_SET_ERR_MSG_FMT_MOD(
2128 extack,
2129 "Query module eeprom by page failed, read %u bytes, err %d",
2130 i, size_read);
2131 return i;
2132 }
2133
2134 i += size_read;
2135 query.offset += size_read;
2136 }
2137
2138 return i;
2139 }
2140
mlx5e_ethtool_flash_device(struct mlx5e_priv * priv,struct ethtool_flash * flash)2141 int mlx5e_ethtool_flash_device(struct mlx5e_priv *priv,
2142 struct ethtool_flash *flash)
2143 {
2144 struct mlx5_core_dev *mdev = priv->mdev;
2145 struct net_device *dev = priv->netdev;
2146 const struct firmware *fw;
2147 int err;
2148
2149 if (flash->region != ETHTOOL_FLASH_ALL_REGIONS)
2150 return -EOPNOTSUPP;
2151
2152 err = request_firmware_direct(&fw, flash->data, &dev->dev);
2153 if (err)
2154 return err;
2155
2156 err = mlx5_firmware_flash(mdev, fw, NULL);
2157 release_firmware(fw);
2158
2159 return err;
2160 }
2161
mlx5e_flash_device(struct net_device * dev,struct ethtool_flash * flash)2162 static int mlx5e_flash_device(struct net_device *dev,
2163 struct ethtool_flash *flash)
2164 {
2165 struct mlx5e_priv *priv = netdev_priv(dev);
2166
2167 return mlx5e_ethtool_flash_device(priv, flash);
2168 }
2169
set_pflag_cqe_based_moder(struct net_device * netdev,bool enable,bool is_rx_cq)2170 static int set_pflag_cqe_based_moder(struct net_device *netdev, bool enable,
2171 bool is_rx_cq)
2172 {
2173 struct mlx5e_priv *priv = netdev_priv(netdev);
2174 u8 cq_period_mode, current_cq_period_mode;
2175 struct mlx5e_params new_params;
2176
2177 if (enable && !MLX5_CAP_GEN(priv->mdev, cq_period_start_from_cqe))
2178 return -EOPNOTSUPP;
2179
2180 cq_period_mode = mlx5e_dim_cq_period_mode(enable);
2181
2182 current_cq_period_mode = is_rx_cq ?
2183 priv->channels.params.rx_cq_moderation.cq_period_mode :
2184 priv->channels.params.tx_cq_moderation.cq_period_mode;
2185
2186 if (cq_period_mode == current_cq_period_mode)
2187 return 0;
2188
2189 new_params = priv->channels.params;
2190 if (is_rx_cq) {
2191 mlx5e_reset_rx_channels_moderation(&priv->channels, cq_period_mode,
2192 false, true);
2193 mlx5e_channels_rx_toggle_dim(&priv->channels);
2194 MLX5E_SET_PFLAG(&new_params, MLX5E_PFLAG_RX_CQE_BASED_MODER,
2195 cq_period_mode);
2196 } else {
2197 mlx5e_reset_tx_channels_moderation(&priv->channels, cq_period_mode,
2198 false, true);
2199 mlx5e_channels_tx_toggle_dim(&priv->channels);
2200 MLX5E_SET_PFLAG(&new_params, MLX5E_PFLAG_TX_CQE_BASED_MODER,
2201 cq_period_mode);
2202 }
2203
2204 /* Update pflags of existing channels without resetting them */
2205 return mlx5e_safe_switch_params(priv, &new_params, NULL, NULL, false);
2206 }
2207
set_pflag_tx_cqe_based_moder(struct net_device * netdev,bool enable)2208 static int set_pflag_tx_cqe_based_moder(struct net_device *netdev, bool enable)
2209 {
2210 return set_pflag_cqe_based_moder(netdev, enable, false);
2211 }
2212
set_pflag_rx_cqe_based_moder(struct net_device * netdev,bool enable)2213 static int set_pflag_rx_cqe_based_moder(struct net_device *netdev, bool enable)
2214 {
2215 return set_pflag_cqe_based_moder(netdev, enable, true);
2216 }
2217
mlx5e_modify_rx_cqe_compression_locked(struct mlx5e_priv * priv,bool new_val,bool rx_filter)2218 int mlx5e_modify_rx_cqe_compression_locked(struct mlx5e_priv *priv, bool new_val, bool rx_filter)
2219 {
2220 bool curr_val = MLX5E_GET_PFLAG(&priv->channels.params, MLX5E_PFLAG_RX_CQE_COMPRESS);
2221 struct mlx5e_params new_params;
2222 int err = 0;
2223
2224 if (!MLX5_CAP_GEN(priv->mdev, cqe_compression))
2225 return new_val ? -EOPNOTSUPP : 0;
2226
2227 if (curr_val == new_val)
2228 return 0;
2229
2230 if (new_val && !mlx5e_profile_feature_cap(priv->profile, PTP_RX) && rx_filter) {
2231 netdev_err(priv->netdev,
2232 "Profile doesn't support enabling of CQE compression while hardware time-stamping is enabled.\n");
2233 return -EINVAL;
2234 }
2235
2236 if (priv->channels.params.packet_merge.type == MLX5E_PACKET_MERGE_SHAMPO) {
2237 netdev_warn(priv->netdev, "Can't set CQE compression with HW-GRO, disable it first.\n");
2238 return -EINVAL;
2239 }
2240
2241 new_params = priv->channels.params;
2242 MLX5E_SET_PFLAG(&new_params, MLX5E_PFLAG_RX_CQE_COMPRESS, new_val);
2243 if (rx_filter)
2244 new_params.ptp_rx = new_val;
2245
2246 if (new_params.ptp_rx == priv->channels.params.ptp_rx)
2247 err = mlx5e_safe_switch_params(priv, &new_params, NULL, NULL, true);
2248 else
2249 err = mlx5e_safe_switch_params(priv, &new_params, mlx5e_ptp_rx_manage_fs_ctx,
2250 &new_params.ptp_rx, true);
2251 if (err)
2252 return err;
2253
2254 netdev_dbg(priv->netdev, "MLX5E: RxCqeCmprss was turned %s\n",
2255 MLX5E_GET_PFLAG(&priv->channels.params,
2256 MLX5E_PFLAG_RX_CQE_COMPRESS) ? "ON" : "OFF");
2257
2258 return 0;
2259 }
2260
set_pflag_rx_cqe_compress(struct net_device * netdev,bool enable)2261 static int set_pflag_rx_cqe_compress(struct net_device *netdev,
2262 bool enable)
2263 {
2264 struct mlx5e_priv *priv = netdev_priv(netdev);
2265 struct mlx5_core_dev *mdev = priv->mdev;
2266 bool rx_filter;
2267 int err;
2268
2269 if (!MLX5_CAP_GEN(mdev, cqe_compression))
2270 return -EOPNOTSUPP;
2271
2272 rx_filter = priv->tstamp.rx_filter != HWTSTAMP_FILTER_NONE;
2273 err = mlx5e_modify_rx_cqe_compression_locked(priv, enable, rx_filter);
2274 if (err)
2275 return err;
2276
2277 priv->channels.params.rx_cqe_compress_def = enable;
2278
2279 return 0;
2280 }
2281
set_pflag_rx_striding_rq(struct net_device * netdev,bool enable)2282 static int set_pflag_rx_striding_rq(struct net_device *netdev, bool enable)
2283 {
2284 struct mlx5e_priv *priv = netdev_priv(netdev);
2285 struct mlx5_core_dev *mdev = priv->mdev;
2286 struct mlx5e_params new_params;
2287 int err;
2288
2289 if (enable) {
2290 /* Checking the regular RQ here; mlx5e_validate_xsk_param called
2291 * from mlx5e_open_xsk will check for each XSK queue, and
2292 * mlx5e_safe_switch_params will be reverted if any check fails.
2293 */
2294 int err = mlx5e_mpwrq_validate_regular(mdev, &priv->channels.params);
2295
2296 if (err)
2297 return err;
2298 } else if (priv->channels.params.packet_merge.type != MLX5E_PACKET_MERGE_NONE) {
2299 netdev_warn(netdev, "Can't set legacy RQ with HW-GRO/LRO, disable them first\n");
2300 return -EINVAL;
2301 }
2302
2303 new_params = priv->channels.params;
2304
2305 MLX5E_SET_PFLAG(&new_params, MLX5E_PFLAG_RX_STRIDING_RQ, enable);
2306 mlx5e_set_rq_type(mdev, &new_params);
2307
2308 err = mlx5e_safe_switch_params(priv, &new_params, NULL, NULL, true);
2309 if (err)
2310 return err;
2311
2312 /* update XDP supported features */
2313 mlx5e_set_xdp_feature(netdev);
2314
2315 return 0;
2316 }
2317
set_pflag_rx_no_csum_complete(struct net_device * netdev,bool enable)2318 static int set_pflag_rx_no_csum_complete(struct net_device *netdev, bool enable)
2319 {
2320 struct mlx5e_priv *priv = netdev_priv(netdev);
2321 struct mlx5e_channels *channels = &priv->channels;
2322 struct mlx5e_channel *c;
2323 int i;
2324
2325 if (!test_bit(MLX5E_STATE_OPENED, &priv->state) ||
2326 priv->channels.params.xdp_prog)
2327 return 0;
2328
2329 for (i = 0; i < channels->num; i++) {
2330 c = channels->c[i];
2331 if (enable)
2332 __set_bit(MLX5E_RQ_STATE_NO_CSUM_COMPLETE, &c->rq.state);
2333 else
2334 __clear_bit(MLX5E_RQ_STATE_NO_CSUM_COMPLETE, &c->rq.state);
2335 }
2336
2337 return 0;
2338 }
2339
set_pflag_tx_mpwqe_common(struct net_device * netdev,u32 flag,bool enable)2340 static int set_pflag_tx_mpwqe_common(struct net_device *netdev, u32 flag, bool enable)
2341 {
2342 struct mlx5e_priv *priv = netdev_priv(netdev);
2343 struct mlx5_core_dev *mdev = priv->mdev;
2344 struct mlx5e_params new_params;
2345
2346 if (enable && !mlx5e_tx_mpwqe_supported(mdev))
2347 return -EOPNOTSUPP;
2348
2349 new_params = priv->channels.params;
2350
2351 MLX5E_SET_PFLAG(&new_params, flag, enable);
2352
2353 return mlx5e_safe_switch_params(priv, &new_params, NULL, NULL, true);
2354 }
2355
set_pflag_xdp_tx_mpwqe(struct net_device * netdev,bool enable)2356 static int set_pflag_xdp_tx_mpwqe(struct net_device *netdev, bool enable)
2357 {
2358 return set_pflag_tx_mpwqe_common(netdev, MLX5E_PFLAG_XDP_TX_MPWQE, enable);
2359 }
2360
set_pflag_skb_tx_mpwqe(struct net_device * netdev,bool enable)2361 static int set_pflag_skb_tx_mpwqe(struct net_device *netdev, bool enable)
2362 {
2363 return set_pflag_tx_mpwqe_common(netdev, MLX5E_PFLAG_SKB_TX_MPWQE, enable);
2364 }
2365
set_pflag_tx_port_ts(struct net_device * netdev,bool enable)2366 static int set_pflag_tx_port_ts(struct net_device *netdev, bool enable)
2367 {
2368 struct mlx5e_priv *priv = netdev_priv(netdev);
2369 struct mlx5_core_dev *mdev = priv->mdev;
2370 struct mlx5e_params new_params;
2371 int err;
2372
2373 if (!MLX5_CAP_GEN(mdev, ts_cqe_to_dest_cqn) ||
2374 !MLX5_CAP_GEN_2(mdev, ts_cqe_metadata_size2wqe_counter))
2375 return -EOPNOTSUPP;
2376
2377 /* Don't allow changing the PTP state if HTB offload is active, because
2378 * the numeration of the QoS SQs will change, while per-queue qdiscs are
2379 * attached.
2380 */
2381 if (mlx5e_selq_is_htb_enabled(&priv->selq)) {
2382 netdev_err(priv->netdev, "%s: HTB offload is active, cannot change the PTP state\n",
2383 __func__);
2384 return -EINVAL;
2385 }
2386
2387 new_params = priv->channels.params;
2388 /* Don't allow enabling TX-port-TS if MQPRIO mode channel offload is
2389 * active, since it defines explicitly which TC accepts the packet.
2390 * This conflicts with TX-port-TS hijacking the PTP traffic to a specific
2391 * HW TX-queue.
2392 */
2393 if (enable && new_params.mqprio.mode == TC_MQPRIO_MODE_CHANNEL) {
2394 netdev_err(priv->netdev,
2395 "%s: MQPRIO mode channel offload is active, cannot set the TX-port-TS\n",
2396 __func__);
2397 return -EINVAL;
2398 }
2399 MLX5E_SET_PFLAG(&new_params, MLX5E_PFLAG_TX_PORT_TS, enable);
2400 /* No need to verify SQ stop room as
2401 * ptpsq.txqsq.stop_room <= generic_sq->stop_room, and both
2402 * has the same log_sq_size.
2403 */
2404
2405 err = mlx5e_safe_switch_params(priv, &new_params,
2406 mlx5e_update_tc_and_tx_queues_ctx, NULL, true);
2407 if (!err)
2408 priv->tx_ptp_opened = true;
2409
2410 return err;
2411 }
2412
2413 static const struct pflag_desc mlx5e_priv_flags[MLX5E_NUM_PFLAGS] = {
2414 { "rx_cqe_moder", set_pflag_rx_cqe_based_moder },
2415 { "tx_cqe_moder", set_pflag_tx_cqe_based_moder },
2416 { "rx_cqe_compress", set_pflag_rx_cqe_compress },
2417 { "rx_striding_rq", set_pflag_rx_striding_rq },
2418 { "rx_no_csum_complete", set_pflag_rx_no_csum_complete },
2419 { "xdp_tx_mpwqe", set_pflag_xdp_tx_mpwqe },
2420 { "skb_tx_mpwqe", set_pflag_skb_tx_mpwqe },
2421 { "tx_port_ts", set_pflag_tx_port_ts },
2422 };
2423
mlx5e_handle_pflag(struct net_device * netdev,u32 wanted_flags,enum mlx5e_priv_flag flag)2424 static int mlx5e_handle_pflag(struct net_device *netdev,
2425 u32 wanted_flags,
2426 enum mlx5e_priv_flag flag)
2427 {
2428 struct mlx5e_priv *priv = netdev_priv(netdev);
2429 bool enable = !!(wanted_flags & BIT(flag));
2430 u32 changes = wanted_flags ^ priv->channels.params.pflags;
2431 int err;
2432
2433 if (!(changes & BIT(flag)))
2434 return 0;
2435
2436 err = mlx5e_priv_flags[flag].handler(netdev, enable);
2437 if (err) {
2438 netdev_err(netdev, "%s private flag '%s' failed err %d\n",
2439 enable ? "Enable" : "Disable", mlx5e_priv_flags[flag].name, err);
2440 return err;
2441 }
2442
2443 MLX5E_SET_PFLAG(&priv->channels.params, flag, enable);
2444 return 0;
2445 }
2446
mlx5e_set_priv_flags(struct net_device * netdev,u32 pflags)2447 static int mlx5e_set_priv_flags(struct net_device *netdev, u32 pflags)
2448 {
2449 struct mlx5e_priv *priv = netdev_priv(netdev);
2450 enum mlx5e_priv_flag pflag;
2451 int err;
2452
2453 mutex_lock(&priv->state_lock);
2454
2455 for (pflag = 0; pflag < MLX5E_NUM_PFLAGS; pflag++) {
2456 err = mlx5e_handle_pflag(netdev, pflags, pflag);
2457 if (err)
2458 break;
2459 }
2460
2461 mutex_unlock(&priv->state_lock);
2462
2463 /* Need to fix some features.. */
2464 netdev_update_features(netdev);
2465
2466 return err;
2467 }
2468
mlx5e_get_priv_flags(struct net_device * netdev)2469 static u32 mlx5e_get_priv_flags(struct net_device *netdev)
2470 {
2471 struct mlx5e_priv *priv = netdev_priv(netdev);
2472
2473 return priv->channels.params.pflags;
2474 }
2475
mlx5e_get_rxfh_fields(struct net_device * dev,struct ethtool_rxfh_fields * info)2476 static int mlx5e_get_rxfh_fields(struct net_device *dev,
2477 struct ethtool_rxfh_fields *info)
2478 {
2479 struct mlx5e_priv *priv = netdev_priv(dev);
2480
2481 return mlx5e_ethtool_get_rxfh_fields(priv, info);
2482 }
2483
mlx5e_set_rxfh_fields(struct net_device * dev,const struct ethtool_rxfh_fields * cmd,struct netlink_ext_ack * extack)2484 static int mlx5e_set_rxfh_fields(struct net_device *dev,
2485 const struct ethtool_rxfh_fields *cmd,
2486 struct netlink_ext_ack *extack)
2487 {
2488 struct mlx5e_priv *priv = netdev_priv(dev);
2489
2490 return mlx5e_ethtool_set_rxfh_fields(priv, cmd, extack);
2491 }
2492
mlx5e_get_rxnfc(struct net_device * dev,struct ethtool_rxnfc * info,u32 * rule_locs)2493 static int mlx5e_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info,
2494 u32 *rule_locs)
2495 {
2496 struct mlx5e_priv *priv = netdev_priv(dev);
2497
2498 /* ETHTOOL_GRXRINGS is needed by ethtool -x which is not part
2499 * of rxnfc. We keep this logic out of mlx5e_ethtool_get_rxnfc,
2500 * to avoid breaking "ethtool -x" when mlx5e_ethtool_get_rxnfc
2501 * is compiled out via CONFIG_MLX5_EN_RXNFC=n.
2502 */
2503 if (info->cmd == ETHTOOL_GRXRINGS) {
2504 info->data = priv->channels.params.num_channels;
2505 return 0;
2506 }
2507
2508 return mlx5e_ethtool_get_rxnfc(priv, info, rule_locs);
2509 }
2510
mlx5e_set_rxnfc(struct net_device * dev,struct ethtool_rxnfc * cmd)2511 static int mlx5e_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
2512 {
2513 struct mlx5e_priv *priv = netdev_priv(dev);
2514
2515 return mlx5e_ethtool_set_rxnfc(priv, cmd);
2516 }
2517
query_port_status_opcode(struct mlx5_core_dev * mdev,u32 * status_opcode)2518 static int query_port_status_opcode(struct mlx5_core_dev *mdev, u32 *status_opcode)
2519 {
2520 struct mlx5_ifc_pddr_troubleshooting_page_bits *pddr_troubleshooting_page;
2521 u32 in[MLX5_ST_SZ_DW(pddr_reg)] = {};
2522 u32 out[MLX5_ST_SZ_DW(pddr_reg)];
2523 int err;
2524
2525 MLX5_SET(pddr_reg, in, local_port, 1);
2526 MLX5_SET(pddr_reg, in, page_select,
2527 MLX5_PDDR_REG_PAGE_SELECT_TROUBLESHOOTING_INFO_PAGE);
2528
2529 pddr_troubleshooting_page = MLX5_ADDR_OF(pddr_reg, in, page_data);
2530 MLX5_SET(pddr_troubleshooting_page, pddr_troubleshooting_page,
2531 group_opcode, MLX5_PDDR_REG_TRBLSH_GROUP_OPCODE_MONITOR);
2532 err = mlx5_core_access_reg(mdev, in, sizeof(in), out,
2533 sizeof(out), MLX5_REG_PDDR, 0, 0);
2534 if (err)
2535 return err;
2536
2537 pddr_troubleshooting_page = MLX5_ADDR_OF(pddr_reg, out, page_data);
2538 *status_opcode = MLX5_GET(pddr_troubleshooting_page, pddr_troubleshooting_page,
2539 status_opcode);
2540 return 0;
2541 }
2542
2543 struct mlx5e_ethtool_link_ext_state_opcode_mapping {
2544 u32 status_opcode;
2545 enum ethtool_link_ext_state link_ext_state;
2546 u8 link_ext_substate;
2547 };
2548
2549 static const struct mlx5e_ethtool_link_ext_state_opcode_mapping
2550 mlx5e_link_ext_state_opcode_map[] = {
2551 /* States relating to the autonegotiation or issues therein */
2552 {2, ETHTOOL_LINK_EXT_STATE_AUTONEG,
2553 ETHTOOL_LINK_EXT_SUBSTATE_AN_NO_PARTNER_DETECTED},
2554 {3, ETHTOOL_LINK_EXT_STATE_AUTONEG,
2555 ETHTOOL_LINK_EXT_SUBSTATE_AN_ACK_NOT_RECEIVED},
2556 {4, ETHTOOL_LINK_EXT_STATE_AUTONEG,
2557 ETHTOOL_LINK_EXT_SUBSTATE_AN_NEXT_PAGE_EXCHANGE_FAILED},
2558 {36, ETHTOOL_LINK_EXT_STATE_AUTONEG,
2559 ETHTOOL_LINK_EXT_SUBSTATE_AN_NO_PARTNER_DETECTED_FORCE_MODE},
2560 {38, ETHTOOL_LINK_EXT_STATE_AUTONEG,
2561 ETHTOOL_LINK_EXT_SUBSTATE_AN_FEC_MISMATCH_DURING_OVERRIDE},
2562 {39, ETHTOOL_LINK_EXT_STATE_AUTONEG,
2563 ETHTOOL_LINK_EXT_SUBSTATE_AN_NO_HCD},
2564
2565 /* Failure during link training */
2566 {5, ETHTOOL_LINK_EXT_STATE_LINK_TRAINING_FAILURE,
2567 ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_FRAME_LOCK_NOT_ACQUIRED},
2568 {6, ETHTOOL_LINK_EXT_STATE_LINK_TRAINING_FAILURE,
2569 ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_LINK_INHIBIT_TIMEOUT},
2570 {7, ETHTOOL_LINK_EXT_STATE_LINK_TRAINING_FAILURE,
2571 ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_LINK_PARTNER_DID_NOT_SET_RECEIVER_READY},
2572 {8, ETHTOOL_LINK_EXT_STATE_LINK_TRAINING_FAILURE, 0},
2573 {14, ETHTOOL_LINK_EXT_STATE_LINK_TRAINING_FAILURE,
2574 ETHTOOL_LINK_EXT_SUBSTATE_LT_REMOTE_FAULT},
2575
2576 /* Logical mismatch in physical coding sublayer or forward error correction sublayer */
2577 {9, ETHTOOL_LINK_EXT_STATE_LINK_LOGICAL_MISMATCH,
2578 ETHTOOL_LINK_EXT_SUBSTATE_LLM_PCS_DID_NOT_ACQUIRE_BLOCK_LOCK},
2579 {10, ETHTOOL_LINK_EXT_STATE_LINK_LOGICAL_MISMATCH,
2580 ETHTOOL_LINK_EXT_SUBSTATE_LLM_PCS_DID_NOT_ACQUIRE_AM_LOCK},
2581 {11, ETHTOOL_LINK_EXT_STATE_LINK_LOGICAL_MISMATCH,
2582 ETHTOOL_LINK_EXT_SUBSTATE_LLM_PCS_DID_NOT_GET_ALIGN_STATUS},
2583 {12, ETHTOOL_LINK_EXT_STATE_LINK_LOGICAL_MISMATCH,
2584 ETHTOOL_LINK_EXT_SUBSTATE_LLM_FC_FEC_IS_NOT_LOCKED},
2585 {13, ETHTOOL_LINK_EXT_STATE_LINK_LOGICAL_MISMATCH,
2586 ETHTOOL_LINK_EXT_SUBSTATE_LLM_RS_FEC_IS_NOT_LOCKED},
2587
2588 /* Signal integrity issues */
2589 {15, ETHTOOL_LINK_EXT_STATE_BAD_SIGNAL_INTEGRITY, 0},
2590 {17, ETHTOOL_LINK_EXT_STATE_BAD_SIGNAL_INTEGRITY,
2591 ETHTOOL_LINK_EXT_SUBSTATE_BSI_LARGE_NUMBER_OF_PHYSICAL_ERRORS},
2592 {42, ETHTOOL_LINK_EXT_STATE_BAD_SIGNAL_INTEGRITY,
2593 ETHTOOL_LINK_EXT_SUBSTATE_BSI_UNSUPPORTED_RATE},
2594
2595 /* No cable connected */
2596 {1024, ETHTOOL_LINK_EXT_STATE_NO_CABLE, 0},
2597
2598 /* Failure is related to cable, e.g., unsupported cable */
2599 {16, ETHTOOL_LINK_EXT_STATE_CABLE_ISSUE,
2600 ETHTOOL_LINK_EXT_SUBSTATE_CI_UNSUPPORTED_CABLE},
2601 {20, ETHTOOL_LINK_EXT_STATE_CABLE_ISSUE,
2602 ETHTOOL_LINK_EXT_SUBSTATE_CI_UNSUPPORTED_CABLE},
2603 {29, ETHTOOL_LINK_EXT_STATE_CABLE_ISSUE,
2604 ETHTOOL_LINK_EXT_SUBSTATE_CI_UNSUPPORTED_CABLE},
2605 {1025, ETHTOOL_LINK_EXT_STATE_CABLE_ISSUE,
2606 ETHTOOL_LINK_EXT_SUBSTATE_CI_UNSUPPORTED_CABLE},
2607 {1029, ETHTOOL_LINK_EXT_STATE_CABLE_ISSUE,
2608 ETHTOOL_LINK_EXT_SUBSTATE_CI_UNSUPPORTED_CABLE},
2609 {1031, ETHTOOL_LINK_EXT_STATE_CABLE_ISSUE, 0},
2610
2611 /* Failure is related to EEPROM, e.g., failure during reading or parsing the data */
2612 {1027, ETHTOOL_LINK_EXT_STATE_EEPROM_ISSUE, 0},
2613
2614 /* Failure during calibration algorithm */
2615 {23, ETHTOOL_LINK_EXT_STATE_CALIBRATION_FAILURE, 0},
2616
2617 /* The hardware is not able to provide the power required from cable or module */
2618 {1032, ETHTOOL_LINK_EXT_STATE_POWER_BUDGET_EXCEEDED, 0},
2619
2620 /* The module is overheated */
2621 {1030, ETHTOOL_LINK_EXT_STATE_OVERHEAT, 0},
2622 };
2623
2624 static void
mlx5e_set_link_ext_state(struct mlx5e_ethtool_link_ext_state_opcode_mapping link_ext_state_mapping,struct ethtool_link_ext_state_info * link_ext_state_info)2625 mlx5e_set_link_ext_state(struct mlx5e_ethtool_link_ext_state_opcode_mapping
2626 link_ext_state_mapping,
2627 struct ethtool_link_ext_state_info *link_ext_state_info)
2628 {
2629 switch (link_ext_state_mapping.link_ext_state) {
2630 case ETHTOOL_LINK_EXT_STATE_AUTONEG:
2631 link_ext_state_info->autoneg =
2632 link_ext_state_mapping.link_ext_substate;
2633 break;
2634 case ETHTOOL_LINK_EXT_STATE_LINK_TRAINING_FAILURE:
2635 link_ext_state_info->link_training =
2636 link_ext_state_mapping.link_ext_substate;
2637 break;
2638 case ETHTOOL_LINK_EXT_STATE_LINK_LOGICAL_MISMATCH:
2639 link_ext_state_info->link_logical_mismatch =
2640 link_ext_state_mapping.link_ext_substate;
2641 break;
2642 case ETHTOOL_LINK_EXT_STATE_BAD_SIGNAL_INTEGRITY:
2643 link_ext_state_info->bad_signal_integrity =
2644 link_ext_state_mapping.link_ext_substate;
2645 break;
2646 case ETHTOOL_LINK_EXT_STATE_CABLE_ISSUE:
2647 link_ext_state_info->cable_issue =
2648 link_ext_state_mapping.link_ext_substate;
2649 break;
2650 default:
2651 break;
2652 }
2653
2654 link_ext_state_info->link_ext_state = link_ext_state_mapping.link_ext_state;
2655 }
2656
2657 static int
mlx5e_get_link_ext_state(struct net_device * dev,struct ethtool_link_ext_state_info * link_ext_state_info)2658 mlx5e_get_link_ext_state(struct net_device *dev,
2659 struct ethtool_link_ext_state_info *link_ext_state_info)
2660 {
2661 struct mlx5e_ethtool_link_ext_state_opcode_mapping link_ext_state_mapping;
2662 struct mlx5e_priv *priv = netdev_priv(dev);
2663 u32 status_opcode = 0;
2664 int i;
2665
2666 /* Exit without data if the interface state is OK, since no extended data is
2667 * available in such case
2668 */
2669 if (netif_carrier_ok(dev))
2670 return -ENODATA;
2671
2672 if (query_port_status_opcode(priv->mdev, &status_opcode) ||
2673 !status_opcode)
2674 return -ENODATA;
2675
2676 for (i = 0; i < ARRAY_SIZE(mlx5e_link_ext_state_opcode_map); i++) {
2677 link_ext_state_mapping = mlx5e_link_ext_state_opcode_map[i];
2678 if (link_ext_state_mapping.status_opcode == status_opcode) {
2679 mlx5e_set_link_ext_state(link_ext_state_mapping,
2680 link_ext_state_info);
2681 return 0;
2682 }
2683 }
2684
2685 return -ENODATA;
2686 }
2687
mlx5e_get_eth_phy_stats(struct net_device * netdev,struct ethtool_eth_phy_stats * phy_stats)2688 static void mlx5e_get_eth_phy_stats(struct net_device *netdev,
2689 struct ethtool_eth_phy_stats *phy_stats)
2690 {
2691 struct mlx5e_priv *priv = netdev_priv(netdev);
2692
2693 mlx5e_stats_eth_phy_get(priv, phy_stats);
2694 }
2695
mlx5e_get_eth_mac_stats(struct net_device * netdev,struct ethtool_eth_mac_stats * mac_stats)2696 static void mlx5e_get_eth_mac_stats(struct net_device *netdev,
2697 struct ethtool_eth_mac_stats *mac_stats)
2698 {
2699 struct mlx5e_priv *priv = netdev_priv(netdev);
2700
2701 mlx5e_stats_eth_mac_get(priv, mac_stats);
2702 }
2703
mlx5e_get_eth_ctrl_stats(struct net_device * netdev,struct ethtool_eth_ctrl_stats * ctrl_stats)2704 static void mlx5e_get_eth_ctrl_stats(struct net_device *netdev,
2705 struct ethtool_eth_ctrl_stats *ctrl_stats)
2706 {
2707 struct mlx5e_priv *priv = netdev_priv(netdev);
2708
2709 mlx5e_stats_eth_ctrl_get(priv, ctrl_stats);
2710 }
2711
mlx5e_get_rmon_stats(struct net_device * netdev,struct ethtool_rmon_stats * rmon_stats,const struct ethtool_rmon_hist_range ** ranges)2712 static void mlx5e_get_rmon_stats(struct net_device *netdev,
2713 struct ethtool_rmon_stats *rmon_stats,
2714 const struct ethtool_rmon_hist_range **ranges)
2715 {
2716 struct mlx5e_priv *priv = netdev_priv(netdev);
2717
2718 mlx5e_stats_rmon_get(priv, rmon_stats, ranges);
2719 }
2720
mlx5e_get_ts_stats(struct net_device * netdev,struct ethtool_ts_stats * ts_stats)2721 static void mlx5e_get_ts_stats(struct net_device *netdev,
2722 struct ethtool_ts_stats *ts_stats)
2723 {
2724 struct mlx5e_priv *priv = netdev_priv(netdev);
2725
2726 mlx5e_stats_ts_get(priv, ts_stats);
2727 }
2728
2729 const struct ethtool_ops mlx5e_ethtool_ops = {
2730 .cap_link_lanes_supported = true,
2731 .rxfh_per_ctx_fields = true,
2732 .rxfh_per_ctx_key = true,
2733 .rxfh_max_num_contexts = MLX5E_MAX_NUM_RSS,
2734 .supported_coalesce_params = ETHTOOL_COALESCE_USECS |
2735 ETHTOOL_COALESCE_MAX_FRAMES |
2736 ETHTOOL_COALESCE_USE_ADAPTIVE |
2737 ETHTOOL_COALESCE_USE_CQE,
2738 .supported_input_xfrm = RXH_XFRM_SYM_OR_XOR,
2739 .supported_ring_params = ETHTOOL_RING_USE_TCP_DATA_SPLIT,
2740 .get_drvinfo = mlx5e_get_drvinfo,
2741 .get_link = ethtool_op_get_link,
2742 .get_link_ext_state = mlx5e_get_link_ext_state,
2743 .get_strings = mlx5e_get_strings,
2744 .get_sset_count = mlx5e_get_sset_count,
2745 .get_ethtool_stats = mlx5e_get_ethtool_stats,
2746 .get_ringparam = mlx5e_get_ringparam,
2747 .set_ringparam = mlx5e_set_ringparam,
2748 .get_channels = mlx5e_get_channels,
2749 .set_channels = mlx5e_set_channels,
2750 .get_coalesce = mlx5e_get_coalesce,
2751 .set_coalesce = mlx5e_set_coalesce,
2752 .get_per_queue_coalesce = mlx5e_get_per_queue_coalesce,
2753 .set_per_queue_coalesce = mlx5e_set_per_queue_coalesce,
2754 .get_link_ksettings = mlx5e_get_link_ksettings,
2755 .set_link_ksettings = mlx5e_set_link_ksettings,
2756 .get_rxfh_key_size = mlx5e_get_rxfh_key_size,
2757 .get_rxfh_indir_size = mlx5e_get_rxfh_indir_size,
2758 .get_rxfh = mlx5e_get_rxfh,
2759 .set_rxfh = mlx5e_set_rxfh,
2760 .get_rxfh_fields = mlx5e_get_rxfh_fields,
2761 .set_rxfh_fields = mlx5e_set_rxfh_fields,
2762 .create_rxfh_context = mlx5e_create_rxfh_context,
2763 .modify_rxfh_context = mlx5e_modify_rxfh_context,
2764 .remove_rxfh_context = mlx5e_remove_rxfh_context,
2765 .get_rxnfc = mlx5e_get_rxnfc,
2766 .set_rxnfc = mlx5e_set_rxnfc,
2767 .get_tunable = mlx5e_get_tunable,
2768 .set_tunable = mlx5e_set_tunable,
2769 .get_pause_stats = mlx5e_get_pause_stats,
2770 .get_pauseparam = mlx5e_get_pauseparam,
2771 .set_pauseparam = mlx5e_set_pauseparam,
2772 .get_ts_info = mlx5e_get_ts_info,
2773 .set_phys_id = mlx5e_set_phys_id,
2774 .get_wol = mlx5e_get_wol,
2775 .set_wol = mlx5e_set_wol,
2776 .get_module_info = mlx5e_get_module_info,
2777 .get_module_eeprom = mlx5e_get_module_eeprom,
2778 .get_module_eeprom_by_page = mlx5e_get_module_eeprom_by_page,
2779 .flash_device = mlx5e_flash_device,
2780 .get_priv_flags = mlx5e_get_priv_flags,
2781 .set_priv_flags = mlx5e_set_priv_flags,
2782 .self_test = mlx5e_self_test,
2783 .get_fec_stats = mlx5e_get_fec_stats,
2784 .get_fecparam = mlx5e_get_fecparam,
2785 .set_fecparam = mlx5e_set_fecparam,
2786 .get_eth_phy_stats = mlx5e_get_eth_phy_stats,
2787 .get_eth_mac_stats = mlx5e_get_eth_mac_stats,
2788 .get_eth_ctrl_stats = mlx5e_get_eth_ctrl_stats,
2789 .get_rmon_stats = mlx5e_get_rmon_stats,
2790 .get_ts_stats = mlx5e_get_ts_stats,
2791 .get_link_ext_stats = mlx5e_get_link_ext_stats
2792 };
2793