1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
2 /*
3  * Copyright 2015-2020 Amazon.com, Inc. or its affiliates. All rights reserved.
4  */
5 
6 #include <linux/ethtool.h>
7 #include <linux/pci.h>
8 
9 #include "ena_netdev.h"
10 
11 struct ena_stats {
12 	char name[ETH_GSTRING_LEN];
13 	int stat_offset;
14 };
15 
16 #define ENA_STAT_ENA_COM_ENTRY(stat) { \
17 	.name = #stat, \
18 	.stat_offset = offsetof(struct ena_com_stats_admin, stat) / sizeof(u64) \
19 }
20 
21 #define ENA_STAT_ENTRY(stat, stat_type) { \
22 	.name = #stat, \
23 	.stat_offset = offsetof(struct ena_stats_##stat_type, stat) / sizeof(u64) \
24 }
25 
26 #define ENA_STAT_HW_ENTRY(stat, stat_type) { \
27 	.name = #stat, \
28 	.stat_offset = offsetof(struct ena_admin_##stat_type, stat) / sizeof(u64) \
29 }
30 
31 #define ENA_STAT_RX_ENTRY(stat) \
32 	ENA_STAT_ENTRY(stat, rx)
33 
34 #define ENA_STAT_TX_ENTRY(stat) \
35 	ENA_STAT_ENTRY(stat, tx)
36 
37 #define ENA_STAT_GLOBAL_ENTRY(stat) \
38 	ENA_STAT_ENTRY(stat, dev)
39 
40 #define ENA_STAT_ENI_ENTRY(stat) \
41 	ENA_STAT_HW_ENTRY(stat, eni_stats)
42 
43 static const struct ena_stats ena_stats_global_strings[] = {
44 	ENA_STAT_GLOBAL_ENTRY(tx_timeout),
45 	ENA_STAT_GLOBAL_ENTRY(suspend),
46 	ENA_STAT_GLOBAL_ENTRY(resume),
47 	ENA_STAT_GLOBAL_ENTRY(wd_expired),
48 	ENA_STAT_GLOBAL_ENTRY(interface_up),
49 	ENA_STAT_GLOBAL_ENTRY(interface_down),
50 	ENA_STAT_GLOBAL_ENTRY(admin_q_pause),
51 };
52 
53 static const struct ena_stats ena_stats_eni_strings[] = {
54 	ENA_STAT_ENI_ENTRY(bw_in_allowance_exceeded),
55 	ENA_STAT_ENI_ENTRY(bw_out_allowance_exceeded),
56 	ENA_STAT_ENI_ENTRY(pps_allowance_exceeded),
57 	ENA_STAT_ENI_ENTRY(conntrack_allowance_exceeded),
58 	ENA_STAT_ENI_ENTRY(linklocal_allowance_exceeded),
59 };
60 
61 static const struct ena_stats ena_stats_tx_strings[] = {
62 	ENA_STAT_TX_ENTRY(cnt),
63 	ENA_STAT_TX_ENTRY(bytes),
64 	ENA_STAT_TX_ENTRY(queue_stop),
65 	ENA_STAT_TX_ENTRY(queue_wakeup),
66 	ENA_STAT_TX_ENTRY(dma_mapping_err),
67 	ENA_STAT_TX_ENTRY(linearize),
68 	ENA_STAT_TX_ENTRY(linearize_failed),
69 	ENA_STAT_TX_ENTRY(napi_comp),
70 	ENA_STAT_TX_ENTRY(tx_poll),
71 	ENA_STAT_TX_ENTRY(doorbells),
72 	ENA_STAT_TX_ENTRY(prepare_ctx_err),
73 	ENA_STAT_TX_ENTRY(bad_req_id),
74 	ENA_STAT_TX_ENTRY(llq_buffer_copy),
75 	ENA_STAT_TX_ENTRY(missed_tx),
76 	ENA_STAT_TX_ENTRY(unmask_interrupt),
77 };
78 
79 static const struct ena_stats ena_stats_rx_strings[] = {
80 	ENA_STAT_RX_ENTRY(cnt),
81 	ENA_STAT_RX_ENTRY(bytes),
82 	ENA_STAT_RX_ENTRY(rx_copybreak_pkt),
83 	ENA_STAT_RX_ENTRY(csum_good),
84 	ENA_STAT_RX_ENTRY(refil_partial),
85 	ENA_STAT_RX_ENTRY(csum_bad),
86 	ENA_STAT_RX_ENTRY(page_alloc_fail),
87 	ENA_STAT_RX_ENTRY(skb_alloc_fail),
88 	ENA_STAT_RX_ENTRY(dma_mapping_err),
89 	ENA_STAT_RX_ENTRY(bad_desc_num),
90 	ENA_STAT_RX_ENTRY(bad_req_id),
91 	ENA_STAT_RX_ENTRY(empty_rx_ring),
92 	ENA_STAT_RX_ENTRY(csum_unchecked),
93 	ENA_STAT_RX_ENTRY(xdp_aborted),
94 	ENA_STAT_RX_ENTRY(xdp_drop),
95 	ENA_STAT_RX_ENTRY(xdp_pass),
96 	ENA_STAT_RX_ENTRY(xdp_tx),
97 	ENA_STAT_RX_ENTRY(xdp_invalid),
98 	ENA_STAT_RX_ENTRY(xdp_redirect),
99 };
100 
101 static const struct ena_stats ena_stats_ena_com_strings[] = {
102 	ENA_STAT_ENA_COM_ENTRY(aborted_cmd),
103 	ENA_STAT_ENA_COM_ENTRY(submitted_cmd),
104 	ENA_STAT_ENA_COM_ENTRY(completed_cmd),
105 	ENA_STAT_ENA_COM_ENTRY(out_of_space),
106 	ENA_STAT_ENA_COM_ENTRY(no_completion),
107 };
108 
109 #define ENA_STATS_ARRAY_GLOBAL		ARRAY_SIZE(ena_stats_global_strings)
110 #define ENA_STATS_ARRAY_TX		ARRAY_SIZE(ena_stats_tx_strings)
111 #define ENA_STATS_ARRAY_RX		ARRAY_SIZE(ena_stats_rx_strings)
112 #define ENA_STATS_ARRAY_ENA_COM		ARRAY_SIZE(ena_stats_ena_com_strings)
113 #define ENA_STATS_ARRAY_ENI(adapter)	ARRAY_SIZE(ena_stats_eni_strings)
114 
115 static void ena_safe_update_stat(u64 *src, u64 *dst,
116 				 struct u64_stats_sync *syncp)
117 {
118 	unsigned int start;
119 
120 	do {
121 		start = u64_stats_fetch_begin_irq(syncp);
122 		*(dst) = *src;
123 	} while (u64_stats_fetch_retry_irq(syncp, start));
124 }
125 
126 static void ena_queue_stats(struct ena_adapter *adapter, u64 **data)
127 {
128 	const struct ena_stats *ena_stats;
129 	struct ena_ring *ring;
130 
131 	u64 *ptr;
132 	int i, j;
133 
134 	for (i = 0; i < adapter->num_io_queues + adapter->xdp_num_queues; i++) {
135 		/* Tx stats */
136 		ring = &adapter->tx_ring[i];
137 
138 		for (j = 0; j < ENA_STATS_ARRAY_TX; j++) {
139 			ena_stats = &ena_stats_tx_strings[j];
140 
141 			ptr = (u64 *)&ring->tx_stats + ena_stats->stat_offset;
142 
143 			ena_safe_update_stat(ptr, (*data)++, &ring->syncp);
144 		}
145 		/* XDP TX queues don't have a RX queue counterpart */
146 		if (!ENA_IS_XDP_INDEX(adapter, i)) {
147 			/* Rx stats */
148 			ring = &adapter->rx_ring[i];
149 
150 			for (j = 0; j < ENA_STATS_ARRAY_RX; j++) {
151 				ena_stats = &ena_stats_rx_strings[j];
152 
153 				ptr = (u64 *)&ring->rx_stats +
154 					ena_stats->stat_offset;
155 
156 				ena_safe_update_stat(ptr, (*data)++, &ring->syncp);
157 			}
158 		}
159 	}
160 }
161 
162 static void ena_dev_admin_queue_stats(struct ena_adapter *adapter, u64 **data)
163 {
164 	const struct ena_stats *ena_stats;
165 	u64 *ptr;
166 	int i;
167 
168 	for (i = 0; i < ENA_STATS_ARRAY_ENA_COM; i++) {
169 		ena_stats = &ena_stats_ena_com_strings[i];
170 
171 		ptr = (u64 *)&adapter->ena_dev->admin_queue.stats +
172 			ena_stats->stat_offset;
173 
174 		*(*data)++ = *ptr;
175 	}
176 }
177 
178 static void ena_get_stats(struct ena_adapter *adapter,
179 			  u64 *data,
180 			  bool eni_stats_needed)
181 {
182 	const struct ena_stats *ena_stats;
183 	u64 *ptr;
184 	int i;
185 
186 	for (i = 0; i < ENA_STATS_ARRAY_GLOBAL; i++) {
187 		ena_stats = &ena_stats_global_strings[i];
188 
189 		ptr = (u64 *)&adapter->dev_stats + ena_stats->stat_offset;
190 
191 		ena_safe_update_stat(ptr, data++, &adapter->syncp);
192 	}
193 
194 	if (eni_stats_needed) {
195 		ena_update_hw_stats(adapter);
196 		for (i = 0; i < ENA_STATS_ARRAY_ENI(adapter); i++) {
197 			ena_stats = &ena_stats_eni_strings[i];
198 
199 			ptr = (u64 *)&adapter->eni_stats +
200 				ena_stats->stat_offset;
201 
202 			ena_safe_update_stat(ptr, data++, &adapter->syncp);
203 		}
204 	}
205 
206 	ena_queue_stats(adapter, &data);
207 	ena_dev_admin_queue_stats(adapter, &data);
208 }
209 
210 static void ena_get_ethtool_stats(struct net_device *netdev,
211 				  struct ethtool_stats *stats,
212 				  u64 *data)
213 {
214 	struct ena_adapter *adapter = netdev_priv(netdev);
215 	struct ena_com_dev *dev = adapter->ena_dev;
216 
217 	ena_get_stats(adapter, data, ena_com_get_cap(dev, ENA_ADMIN_ENI_STATS));
218 }
219 
220 static int ena_get_sw_stats_count(struct ena_adapter *adapter)
221 {
222 	return adapter->num_io_queues * (ENA_STATS_ARRAY_TX + ENA_STATS_ARRAY_RX)
223 		+ adapter->xdp_num_queues * ENA_STATS_ARRAY_TX
224 		+ ENA_STATS_ARRAY_GLOBAL + ENA_STATS_ARRAY_ENA_COM;
225 }
226 
227 static int ena_get_hw_stats_count(struct ena_adapter *adapter)
228 {
229 	bool supported = ena_com_get_cap(adapter->ena_dev, ENA_ADMIN_ENI_STATS);
230 
231 	return ENA_STATS_ARRAY_ENI(adapter) * supported;
232 }
233 
234 int ena_get_sset_count(struct net_device *netdev, int sset)
235 {
236 	struct ena_adapter *adapter = netdev_priv(netdev);
237 
238 	switch (sset) {
239 	case ETH_SS_STATS:
240 		return ena_get_sw_stats_count(adapter) +
241 		       ena_get_hw_stats_count(adapter);
242 	}
243 
244 	return -EOPNOTSUPP;
245 }
246 
247 static void ena_queue_strings(struct ena_adapter *adapter, u8 **data)
248 {
249 	const struct ena_stats *ena_stats;
250 	bool is_xdp;
251 	int i, j;
252 
253 	for (i = 0; i < adapter->num_io_queues + adapter->xdp_num_queues; i++) {
254 		is_xdp = ENA_IS_XDP_INDEX(adapter, i);
255 		/* Tx stats */
256 		for (j = 0; j < ENA_STATS_ARRAY_TX; j++) {
257 			ena_stats = &ena_stats_tx_strings[j];
258 
259 			ethtool_sprintf(data,
260 					"queue_%u_%s_%s", i,
261 					is_xdp ? "xdp_tx" : "tx",
262 					ena_stats->name);
263 		}
264 
265 		if (!is_xdp) {
266 			/* RX stats, in XDP there isn't a RX queue
267 			 * counterpart
268 			 */
269 			for (j = 0; j < ENA_STATS_ARRAY_RX; j++) {
270 				ena_stats = &ena_stats_rx_strings[j];
271 
272 				ethtool_sprintf(data,
273 						"queue_%u_rx_%s", i,
274 						ena_stats->name);
275 			}
276 		}
277 	}
278 }
279 
280 static void ena_com_dev_strings(u8 **data)
281 {
282 	const struct ena_stats *ena_stats;
283 	int i;
284 
285 	for (i = 0; i < ENA_STATS_ARRAY_ENA_COM; i++) {
286 		ena_stats = &ena_stats_ena_com_strings[i];
287 
288 		ethtool_sprintf(data,
289 				"ena_admin_q_%s", ena_stats->name);
290 	}
291 }
292 
293 static void ena_get_strings(struct ena_adapter *adapter,
294 			    u8 *data,
295 			    bool eni_stats_needed)
296 {
297 	const struct ena_stats *ena_stats;
298 	int i;
299 
300 	for (i = 0; i < ENA_STATS_ARRAY_GLOBAL; i++) {
301 		ena_stats = &ena_stats_global_strings[i];
302 		ethtool_sprintf(&data, ena_stats->name);
303 	}
304 
305 	if (eni_stats_needed) {
306 		for (i = 0; i < ENA_STATS_ARRAY_ENI(adapter); i++) {
307 			ena_stats = &ena_stats_eni_strings[i];
308 			ethtool_sprintf(&data, ena_stats->name);
309 		}
310 	}
311 
312 	ena_queue_strings(adapter, &data);
313 	ena_com_dev_strings(&data);
314 }
315 
316 static void ena_get_ethtool_strings(struct net_device *netdev,
317 				    u32 sset,
318 				    u8 *data)
319 {
320 	struct ena_adapter *adapter = netdev_priv(netdev);
321 	struct ena_com_dev *dev = adapter->ena_dev;
322 
323 	switch (sset) {
324 	case ETH_SS_STATS:
325 		ena_get_strings(adapter, data, ena_com_get_cap(dev, ENA_ADMIN_ENI_STATS));
326 		break;
327 	}
328 }
329 
330 static int ena_get_link_ksettings(struct net_device *netdev,
331 				  struct ethtool_link_ksettings *link_ksettings)
332 {
333 	struct ena_adapter *adapter = netdev_priv(netdev);
334 	struct ena_com_dev *ena_dev = adapter->ena_dev;
335 	struct ena_admin_get_feature_link_desc *link;
336 	struct ena_admin_get_feat_resp feat_resp;
337 	int rc;
338 
339 	rc = ena_com_get_link_params(ena_dev, &feat_resp);
340 	if (rc)
341 		return rc;
342 
343 	link = &feat_resp.u.link;
344 	link_ksettings->base.speed = link->speed;
345 
346 	if (link->flags & ENA_ADMIN_GET_FEATURE_LINK_DESC_AUTONEG_MASK) {
347 		ethtool_link_ksettings_add_link_mode(link_ksettings,
348 						     supported, Autoneg);
349 		ethtool_link_ksettings_add_link_mode(link_ksettings,
350 						     supported, Autoneg);
351 	}
352 
353 	link_ksettings->base.autoneg =
354 		(link->flags & ENA_ADMIN_GET_FEATURE_LINK_DESC_AUTONEG_MASK) ?
355 		AUTONEG_ENABLE : AUTONEG_DISABLE;
356 
357 	link_ksettings->base.duplex = DUPLEX_FULL;
358 
359 	return 0;
360 }
361 
362 static int ena_get_coalesce(struct net_device *net_dev,
363 			    struct ethtool_coalesce *coalesce,
364 			    struct kernel_ethtool_coalesce *kernel_coal,
365 			    struct netlink_ext_ack *extack)
366 {
367 	struct ena_adapter *adapter = netdev_priv(net_dev);
368 	struct ena_com_dev *ena_dev = adapter->ena_dev;
369 
370 	if (!ena_com_interrupt_moderation_supported(ena_dev))
371 		return -EOPNOTSUPP;
372 
373 	coalesce->tx_coalesce_usecs =
374 		ena_com_get_nonadaptive_moderation_interval_tx(ena_dev) *
375 			ena_dev->intr_delay_resolution;
376 
377 	coalesce->rx_coalesce_usecs =
378 		ena_com_get_nonadaptive_moderation_interval_rx(ena_dev)
379 		* ena_dev->intr_delay_resolution;
380 
381 	coalesce->use_adaptive_rx_coalesce =
382 		ena_com_get_adaptive_moderation_enabled(ena_dev);
383 
384 	return 0;
385 }
386 
387 static void ena_update_tx_rings_nonadaptive_intr_moderation(struct ena_adapter *adapter)
388 {
389 	unsigned int val;
390 	int i;
391 
392 	val = ena_com_get_nonadaptive_moderation_interval_tx(adapter->ena_dev);
393 
394 	for (i = 0; i < adapter->num_io_queues; i++)
395 		adapter->tx_ring[i].smoothed_interval = val;
396 }
397 
398 static void ena_update_rx_rings_nonadaptive_intr_moderation(struct ena_adapter *adapter)
399 {
400 	unsigned int val;
401 	int i;
402 
403 	val = ena_com_get_nonadaptive_moderation_interval_rx(adapter->ena_dev);
404 
405 	for (i = 0; i < adapter->num_io_queues; i++)
406 		adapter->rx_ring[i].smoothed_interval = val;
407 }
408 
409 static int ena_set_coalesce(struct net_device *net_dev,
410 			    struct ethtool_coalesce *coalesce,
411 			    struct kernel_ethtool_coalesce *kernel_coal,
412 			    struct netlink_ext_ack *extack)
413 {
414 	struct ena_adapter *adapter = netdev_priv(net_dev);
415 	struct ena_com_dev *ena_dev = adapter->ena_dev;
416 	int rc;
417 
418 	if (!ena_com_interrupt_moderation_supported(ena_dev))
419 		return -EOPNOTSUPP;
420 
421 	rc = ena_com_update_nonadaptive_moderation_interval_tx(ena_dev,
422 							       coalesce->tx_coalesce_usecs);
423 	if (rc)
424 		return rc;
425 
426 	ena_update_tx_rings_nonadaptive_intr_moderation(adapter);
427 
428 	rc = ena_com_update_nonadaptive_moderation_interval_rx(ena_dev,
429 							       coalesce->rx_coalesce_usecs);
430 	if (rc)
431 		return rc;
432 
433 	ena_update_rx_rings_nonadaptive_intr_moderation(adapter);
434 
435 	if (coalesce->use_adaptive_rx_coalesce &&
436 	    !ena_com_get_adaptive_moderation_enabled(ena_dev))
437 		ena_com_enable_adaptive_moderation(ena_dev);
438 
439 	if (!coalesce->use_adaptive_rx_coalesce &&
440 	    ena_com_get_adaptive_moderation_enabled(ena_dev))
441 		ena_com_disable_adaptive_moderation(ena_dev);
442 
443 	return 0;
444 }
445 
446 static u32 ena_get_msglevel(struct net_device *netdev)
447 {
448 	struct ena_adapter *adapter = netdev_priv(netdev);
449 
450 	return adapter->msg_enable;
451 }
452 
453 static void ena_set_msglevel(struct net_device *netdev, u32 value)
454 {
455 	struct ena_adapter *adapter = netdev_priv(netdev);
456 
457 	adapter->msg_enable = value;
458 }
459 
460 static void ena_get_drvinfo(struct net_device *dev,
461 			    struct ethtool_drvinfo *info)
462 {
463 	struct ena_adapter *adapter = netdev_priv(dev);
464 
465 	strlcpy(info->driver, DRV_MODULE_NAME, sizeof(info->driver));
466 	strlcpy(info->bus_info, pci_name(adapter->pdev),
467 		sizeof(info->bus_info));
468 }
469 
470 static void ena_get_ringparam(struct net_device *netdev,
471 			      struct ethtool_ringparam *ring,
472 			      struct kernel_ethtool_ringparam *kernel_ring,
473 			      struct netlink_ext_ack *extack)
474 {
475 	struct ena_adapter *adapter = netdev_priv(netdev);
476 
477 	ring->tx_max_pending = adapter->max_tx_ring_size;
478 	ring->rx_max_pending = adapter->max_rx_ring_size;
479 	ring->tx_pending = adapter->tx_ring[0].ring_size;
480 	ring->rx_pending = adapter->rx_ring[0].ring_size;
481 }
482 
483 static int ena_set_ringparam(struct net_device *netdev,
484 			     struct ethtool_ringparam *ring,
485 			     struct kernel_ethtool_ringparam *kernel_ring,
486 			     struct netlink_ext_ack *extack)
487 {
488 	struct ena_adapter *adapter = netdev_priv(netdev);
489 	u32 new_tx_size, new_rx_size;
490 
491 	new_tx_size = ring->tx_pending < ENA_MIN_RING_SIZE ?
492 			ENA_MIN_RING_SIZE : ring->tx_pending;
493 	new_tx_size = rounddown_pow_of_two(new_tx_size);
494 
495 	new_rx_size = ring->rx_pending < ENA_MIN_RING_SIZE ?
496 			ENA_MIN_RING_SIZE : ring->rx_pending;
497 	new_rx_size = rounddown_pow_of_two(new_rx_size);
498 
499 	if (new_tx_size == adapter->requested_tx_ring_size &&
500 	    new_rx_size == adapter->requested_rx_ring_size)
501 		return 0;
502 
503 	return ena_update_queue_sizes(adapter, new_tx_size, new_rx_size);
504 }
505 
506 static u32 ena_flow_hash_to_flow_type(u16 hash_fields)
507 {
508 	u32 data = 0;
509 
510 	if (hash_fields & ENA_ADMIN_RSS_L2_DA)
511 		data |= RXH_L2DA;
512 
513 	if (hash_fields & ENA_ADMIN_RSS_L3_DA)
514 		data |= RXH_IP_DST;
515 
516 	if (hash_fields & ENA_ADMIN_RSS_L3_SA)
517 		data |= RXH_IP_SRC;
518 
519 	if (hash_fields & ENA_ADMIN_RSS_L4_DP)
520 		data |= RXH_L4_B_2_3;
521 
522 	if (hash_fields & ENA_ADMIN_RSS_L4_SP)
523 		data |= RXH_L4_B_0_1;
524 
525 	return data;
526 }
527 
528 static u16 ena_flow_data_to_flow_hash(u32 hash_fields)
529 {
530 	u16 data = 0;
531 
532 	if (hash_fields & RXH_L2DA)
533 		data |= ENA_ADMIN_RSS_L2_DA;
534 
535 	if (hash_fields & RXH_IP_DST)
536 		data |= ENA_ADMIN_RSS_L3_DA;
537 
538 	if (hash_fields & RXH_IP_SRC)
539 		data |= ENA_ADMIN_RSS_L3_SA;
540 
541 	if (hash_fields & RXH_L4_B_2_3)
542 		data |= ENA_ADMIN_RSS_L4_DP;
543 
544 	if (hash_fields & RXH_L4_B_0_1)
545 		data |= ENA_ADMIN_RSS_L4_SP;
546 
547 	return data;
548 }
549 
550 static int ena_get_rss_hash(struct ena_com_dev *ena_dev,
551 			    struct ethtool_rxnfc *cmd)
552 {
553 	enum ena_admin_flow_hash_proto proto;
554 	u16 hash_fields;
555 	int rc;
556 
557 	cmd->data = 0;
558 
559 	switch (cmd->flow_type) {
560 	case TCP_V4_FLOW:
561 		proto = ENA_ADMIN_RSS_TCP4;
562 		break;
563 	case UDP_V4_FLOW:
564 		proto = ENA_ADMIN_RSS_UDP4;
565 		break;
566 	case TCP_V6_FLOW:
567 		proto = ENA_ADMIN_RSS_TCP6;
568 		break;
569 	case UDP_V6_FLOW:
570 		proto = ENA_ADMIN_RSS_UDP6;
571 		break;
572 	case IPV4_FLOW:
573 		proto = ENA_ADMIN_RSS_IP4;
574 		break;
575 	case IPV6_FLOW:
576 		proto = ENA_ADMIN_RSS_IP6;
577 		break;
578 	case ETHER_FLOW:
579 		proto = ENA_ADMIN_RSS_NOT_IP;
580 		break;
581 	case AH_V4_FLOW:
582 	case ESP_V4_FLOW:
583 	case AH_V6_FLOW:
584 	case ESP_V6_FLOW:
585 	case SCTP_V4_FLOW:
586 	case AH_ESP_V4_FLOW:
587 		return -EOPNOTSUPP;
588 	default:
589 		return -EINVAL;
590 	}
591 
592 	rc = ena_com_get_hash_ctrl(ena_dev, proto, &hash_fields);
593 	if (rc)
594 		return rc;
595 
596 	cmd->data = ena_flow_hash_to_flow_type(hash_fields);
597 
598 	return 0;
599 }
600 
601 static int ena_set_rss_hash(struct ena_com_dev *ena_dev,
602 			    struct ethtool_rxnfc *cmd)
603 {
604 	enum ena_admin_flow_hash_proto proto;
605 	u16 hash_fields;
606 
607 	switch (cmd->flow_type) {
608 	case TCP_V4_FLOW:
609 		proto = ENA_ADMIN_RSS_TCP4;
610 		break;
611 	case UDP_V4_FLOW:
612 		proto = ENA_ADMIN_RSS_UDP4;
613 		break;
614 	case TCP_V6_FLOW:
615 		proto = ENA_ADMIN_RSS_TCP6;
616 		break;
617 	case UDP_V6_FLOW:
618 		proto = ENA_ADMIN_RSS_UDP6;
619 		break;
620 	case IPV4_FLOW:
621 		proto = ENA_ADMIN_RSS_IP4;
622 		break;
623 	case IPV6_FLOW:
624 		proto = ENA_ADMIN_RSS_IP6;
625 		break;
626 	case ETHER_FLOW:
627 		proto = ENA_ADMIN_RSS_NOT_IP;
628 		break;
629 	case AH_V4_FLOW:
630 	case ESP_V4_FLOW:
631 	case AH_V6_FLOW:
632 	case ESP_V6_FLOW:
633 	case SCTP_V4_FLOW:
634 	case AH_ESP_V4_FLOW:
635 		return -EOPNOTSUPP;
636 	default:
637 		return -EINVAL;
638 	}
639 
640 	hash_fields = ena_flow_data_to_flow_hash(cmd->data);
641 
642 	return ena_com_fill_hash_ctrl(ena_dev, proto, hash_fields);
643 }
644 
645 static int ena_set_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *info)
646 {
647 	struct ena_adapter *adapter = netdev_priv(netdev);
648 	int rc = 0;
649 
650 	switch (info->cmd) {
651 	case ETHTOOL_SRXFH:
652 		rc = ena_set_rss_hash(adapter->ena_dev, info);
653 		break;
654 	case ETHTOOL_SRXCLSRLDEL:
655 	case ETHTOOL_SRXCLSRLINS:
656 	default:
657 		netif_err(adapter, drv, netdev,
658 			  "Command parameter %d is not supported\n", info->cmd);
659 		rc = -EOPNOTSUPP;
660 	}
661 
662 	return rc;
663 }
664 
665 static int ena_get_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *info,
666 			 u32 *rules)
667 {
668 	struct ena_adapter *adapter = netdev_priv(netdev);
669 	int rc = 0;
670 
671 	switch (info->cmd) {
672 	case ETHTOOL_GRXRINGS:
673 		info->data = adapter->num_io_queues;
674 		rc = 0;
675 		break;
676 	case ETHTOOL_GRXFH:
677 		rc = ena_get_rss_hash(adapter->ena_dev, info);
678 		break;
679 	case ETHTOOL_GRXCLSRLCNT:
680 	case ETHTOOL_GRXCLSRULE:
681 	case ETHTOOL_GRXCLSRLALL:
682 	default:
683 		netif_err(adapter, drv, netdev,
684 			  "Command parameter %d is not supported\n", info->cmd);
685 		rc = -EOPNOTSUPP;
686 	}
687 
688 	return rc;
689 }
690 
691 static u32 ena_get_rxfh_indir_size(struct net_device *netdev)
692 {
693 	return ENA_RX_RSS_TABLE_SIZE;
694 }
695 
696 static u32 ena_get_rxfh_key_size(struct net_device *netdev)
697 {
698 	return ENA_HASH_KEY_SIZE;
699 }
700 
701 static int ena_indirection_table_set(struct ena_adapter *adapter,
702 				     const u32 *indir)
703 {
704 	struct ena_com_dev *ena_dev = adapter->ena_dev;
705 	int i, rc;
706 
707 	for (i = 0; i < ENA_RX_RSS_TABLE_SIZE; i++) {
708 		rc = ena_com_indirect_table_fill_entry(ena_dev,
709 						       i,
710 						       ENA_IO_RXQ_IDX(indir[i]));
711 		if (unlikely(rc)) {
712 			netif_err(adapter, drv, adapter->netdev,
713 				  "Cannot fill indirect table (index is too large)\n");
714 			return rc;
715 		}
716 	}
717 
718 	rc = ena_com_indirect_table_set(ena_dev);
719 	if (rc) {
720 		netif_err(adapter, drv, adapter->netdev,
721 			  "Cannot set indirect table\n");
722 		return rc == -EPERM ? -EOPNOTSUPP : rc;
723 	}
724 	return rc;
725 }
726 
727 static int ena_indirection_table_get(struct ena_adapter *adapter, u32 *indir)
728 {
729 	struct ena_com_dev *ena_dev = adapter->ena_dev;
730 	int i, rc;
731 
732 	if (!indir)
733 		return 0;
734 
735 	rc = ena_com_indirect_table_get(ena_dev, indir);
736 	if (rc)
737 		return rc;
738 
739 	/* Our internal representation of the indices is: even indices
740 	 * for Tx and uneven indices for Rx. We need to convert the Rx
741 	 * indices to be consecutive
742 	 */
743 	for (i = 0; i < ENA_RX_RSS_TABLE_SIZE; i++)
744 		indir[i] = ENA_IO_RXQ_IDX_TO_COMBINED_IDX(indir[i]);
745 
746 	return rc;
747 }
748 
749 static int ena_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key,
750 			u8 *hfunc)
751 {
752 	struct ena_adapter *adapter = netdev_priv(netdev);
753 	enum ena_admin_hash_functions ena_func;
754 	u8 func;
755 	int rc;
756 
757 	rc = ena_indirection_table_get(adapter, indir);
758 	if (rc)
759 		return rc;
760 
761 	/* We call this function in order to check if the device
762 	 * supports getting/setting the hash function.
763 	 */
764 	rc = ena_com_get_hash_function(adapter->ena_dev, &ena_func);
765 	if (rc) {
766 		if (rc == -EOPNOTSUPP)
767 			rc = 0;
768 
769 		return rc;
770 	}
771 
772 	rc = ena_com_get_hash_key(adapter->ena_dev, key);
773 	if (rc)
774 		return rc;
775 
776 	switch (ena_func) {
777 	case ENA_ADMIN_TOEPLITZ:
778 		func = ETH_RSS_HASH_TOP;
779 		break;
780 	case ENA_ADMIN_CRC32:
781 		func = ETH_RSS_HASH_CRC32;
782 		break;
783 	default:
784 		netif_err(adapter, drv, netdev,
785 			  "Command parameter is not supported\n");
786 		return -EOPNOTSUPP;
787 	}
788 
789 	if (hfunc)
790 		*hfunc = func;
791 
792 	return 0;
793 }
794 
795 static int ena_set_rxfh(struct net_device *netdev, const u32 *indir,
796 			const u8 *key, const u8 hfunc)
797 {
798 	struct ena_adapter *adapter = netdev_priv(netdev);
799 	struct ena_com_dev *ena_dev = adapter->ena_dev;
800 	enum ena_admin_hash_functions func = 0;
801 	int rc;
802 
803 	if (indir) {
804 		rc = ena_indirection_table_set(adapter, indir);
805 		if (rc)
806 			return rc;
807 	}
808 
809 	switch (hfunc) {
810 	case ETH_RSS_HASH_NO_CHANGE:
811 		func = ena_com_get_current_hash_function(ena_dev);
812 		break;
813 	case ETH_RSS_HASH_TOP:
814 		func = ENA_ADMIN_TOEPLITZ;
815 		break;
816 	case ETH_RSS_HASH_CRC32:
817 		func = ENA_ADMIN_CRC32;
818 		break;
819 	default:
820 		netif_err(adapter, drv, netdev, "Unsupported hfunc %d\n",
821 			  hfunc);
822 		return -EOPNOTSUPP;
823 	}
824 
825 	if (key || func) {
826 		rc = ena_com_fill_hash_function(ena_dev, func, key,
827 						ENA_HASH_KEY_SIZE,
828 						0xFFFFFFFF);
829 		if (unlikely(rc)) {
830 			netif_err(adapter, drv, netdev, "Cannot fill key\n");
831 			return rc == -EPERM ? -EOPNOTSUPP : rc;
832 		}
833 	}
834 
835 	return 0;
836 }
837 
838 static void ena_get_channels(struct net_device *netdev,
839 			     struct ethtool_channels *channels)
840 {
841 	struct ena_adapter *adapter = netdev_priv(netdev);
842 
843 	channels->max_combined = adapter->max_num_io_queues;
844 	channels->combined_count = adapter->num_io_queues;
845 }
846 
847 static int ena_set_channels(struct net_device *netdev,
848 			    struct ethtool_channels *channels)
849 {
850 	struct ena_adapter *adapter = netdev_priv(netdev);
851 	u32 count = channels->combined_count;
852 	/* The check for max value is already done in ethtool */
853 	if (count < ENA_MIN_NUM_IO_QUEUES ||
854 	    (ena_xdp_present(adapter) &&
855 	    !ena_xdp_legal_queue_count(adapter, count)))
856 		return -EINVAL;
857 
858 	return ena_update_queue_count(adapter, count);
859 }
860 
861 static int ena_get_tunable(struct net_device *netdev,
862 			   const struct ethtool_tunable *tuna, void *data)
863 {
864 	struct ena_adapter *adapter = netdev_priv(netdev);
865 	int ret = 0;
866 
867 	switch (tuna->id) {
868 	case ETHTOOL_RX_COPYBREAK:
869 		*(u32 *)data = adapter->rx_copybreak;
870 		break;
871 	default:
872 		ret = -EINVAL;
873 		break;
874 	}
875 
876 	return ret;
877 }
878 
879 static int ena_set_tunable(struct net_device *netdev,
880 			   const struct ethtool_tunable *tuna,
881 			   const void *data)
882 {
883 	struct ena_adapter *adapter = netdev_priv(netdev);
884 	int ret = 0;
885 	u32 len;
886 
887 	switch (tuna->id) {
888 	case ETHTOOL_RX_COPYBREAK:
889 		len = *(u32 *)data;
890 		if (len > adapter->netdev->mtu) {
891 			ret = -EINVAL;
892 			break;
893 		}
894 		adapter->rx_copybreak = len;
895 		break;
896 	default:
897 		ret = -EINVAL;
898 		break;
899 	}
900 
901 	return ret;
902 }
903 
904 static const struct ethtool_ops ena_ethtool_ops = {
905 	.supported_coalesce_params = ETHTOOL_COALESCE_USECS |
906 				     ETHTOOL_COALESCE_USE_ADAPTIVE_RX,
907 	.get_link_ksettings	= ena_get_link_ksettings,
908 	.get_drvinfo		= ena_get_drvinfo,
909 	.get_msglevel		= ena_get_msglevel,
910 	.set_msglevel		= ena_set_msglevel,
911 	.get_link		= ethtool_op_get_link,
912 	.get_coalesce		= ena_get_coalesce,
913 	.set_coalesce		= ena_set_coalesce,
914 	.get_ringparam		= ena_get_ringparam,
915 	.set_ringparam		= ena_set_ringparam,
916 	.get_sset_count         = ena_get_sset_count,
917 	.get_strings		= ena_get_ethtool_strings,
918 	.get_ethtool_stats      = ena_get_ethtool_stats,
919 	.get_rxnfc		= ena_get_rxnfc,
920 	.set_rxnfc		= ena_set_rxnfc,
921 	.get_rxfh_indir_size    = ena_get_rxfh_indir_size,
922 	.get_rxfh_key_size	= ena_get_rxfh_key_size,
923 	.get_rxfh		= ena_get_rxfh,
924 	.set_rxfh		= ena_set_rxfh,
925 	.get_channels		= ena_get_channels,
926 	.set_channels		= ena_set_channels,
927 	.get_tunable		= ena_get_tunable,
928 	.set_tunable		= ena_set_tunable,
929 	.get_ts_info            = ethtool_op_get_ts_info,
930 };
931 
932 void ena_set_ethtool_ops(struct net_device *netdev)
933 {
934 	netdev->ethtool_ops = &ena_ethtool_ops;
935 }
936 
937 static void ena_dump_stats_ex(struct ena_adapter *adapter, u8 *buf)
938 {
939 	struct net_device *netdev = adapter->netdev;
940 	u8 *strings_buf;
941 	u64 *data_buf;
942 	int strings_num;
943 	int i, rc;
944 
945 	strings_num = ena_get_sw_stats_count(adapter);
946 	if (strings_num <= 0) {
947 		netif_err(adapter, drv, netdev, "Can't get stats num\n");
948 		return;
949 	}
950 
951 	strings_buf = devm_kcalloc(&adapter->pdev->dev,
952 				   ETH_GSTRING_LEN, strings_num,
953 				   GFP_ATOMIC);
954 	if (!strings_buf) {
955 		netif_err(adapter, drv, netdev,
956 			  "Failed to allocate strings_buf\n");
957 		return;
958 	}
959 
960 	data_buf = devm_kcalloc(&adapter->pdev->dev,
961 				strings_num, sizeof(u64),
962 				GFP_ATOMIC);
963 	if (!data_buf) {
964 		netif_err(adapter, drv, netdev,
965 			  "Failed to allocate data buf\n");
966 		devm_kfree(&adapter->pdev->dev, strings_buf);
967 		return;
968 	}
969 
970 	ena_get_strings(adapter, strings_buf, false);
971 	ena_get_stats(adapter, data_buf, false);
972 
973 	/* If there is a buffer, dump stats, otherwise print them to dmesg */
974 	if (buf)
975 		for (i = 0; i < strings_num; i++) {
976 			rc = snprintf(buf, ETH_GSTRING_LEN + sizeof(u64),
977 				      "%s %llu\n",
978 				      strings_buf + i * ETH_GSTRING_LEN,
979 				      data_buf[i]);
980 			buf += rc;
981 		}
982 	else
983 		for (i = 0; i < strings_num; i++)
984 			netif_err(adapter, drv, netdev, "%s: %llu\n",
985 				  strings_buf + i * ETH_GSTRING_LEN,
986 				  data_buf[i]);
987 
988 	devm_kfree(&adapter->pdev->dev, strings_buf);
989 	devm_kfree(&adapter->pdev->dev, data_buf);
990 }
991 
992 void ena_dump_stats_to_buf(struct ena_adapter *adapter, u8 *buf)
993 {
994 	if (!buf)
995 		return;
996 
997 	ena_dump_stats_ex(adapter, buf);
998 }
999 
1000 void ena_dump_stats_to_dmesg(struct ena_adapter *adapter)
1001 {
1002 	ena_dump_stats_ex(adapter, NULL);
1003 }
1004