1 // SPDX-License-Identifier: GPL-2.0-only
2 // Copyright 2013 Cisco Systems, Inc.  All rights reserved.
3 
4 #include <linux/netdevice.h>
5 #include <linux/ethtool.h>
6 #include <linux/net_tstamp.h>
7 
8 #include "enic_res.h"
9 #include "enic.h"
10 #include "enic_dev.h"
11 #include "enic_clsf.h"
12 #include "vnic_rss.h"
13 #include "vnic_stats.h"
14 
15 struct enic_stat {
16 	char name[ETH_GSTRING_LEN];
17 	unsigned int index;
18 };
19 
20 #define ENIC_TX_STAT(stat) { \
21 	.name = #stat, \
22 	.index = offsetof(struct vnic_tx_stats, stat) / sizeof(u64) \
23 }
24 
25 #define ENIC_RX_STAT(stat) { \
26 	.name = #stat, \
27 	.index = offsetof(struct vnic_rx_stats, stat) / sizeof(u64) \
28 }
29 
30 #define ENIC_GEN_STAT(stat) { \
31 	.name = #stat, \
32 	.index = offsetof(struct vnic_gen_stats, stat) / sizeof(u64)\
33 }
34 
35 static const struct enic_stat enic_tx_stats[] = {
36 	ENIC_TX_STAT(tx_frames_ok),
37 	ENIC_TX_STAT(tx_unicast_frames_ok),
38 	ENIC_TX_STAT(tx_multicast_frames_ok),
39 	ENIC_TX_STAT(tx_broadcast_frames_ok),
40 	ENIC_TX_STAT(tx_bytes_ok),
41 	ENIC_TX_STAT(tx_unicast_bytes_ok),
42 	ENIC_TX_STAT(tx_multicast_bytes_ok),
43 	ENIC_TX_STAT(tx_broadcast_bytes_ok),
44 	ENIC_TX_STAT(tx_drops),
45 	ENIC_TX_STAT(tx_errors),
46 	ENIC_TX_STAT(tx_tso),
47 };
48 
49 static const struct enic_stat enic_rx_stats[] = {
50 	ENIC_RX_STAT(rx_frames_ok),
51 	ENIC_RX_STAT(rx_frames_total),
52 	ENIC_RX_STAT(rx_unicast_frames_ok),
53 	ENIC_RX_STAT(rx_multicast_frames_ok),
54 	ENIC_RX_STAT(rx_broadcast_frames_ok),
55 	ENIC_RX_STAT(rx_bytes_ok),
56 	ENIC_RX_STAT(rx_unicast_bytes_ok),
57 	ENIC_RX_STAT(rx_multicast_bytes_ok),
58 	ENIC_RX_STAT(rx_broadcast_bytes_ok),
59 	ENIC_RX_STAT(rx_drop),
60 	ENIC_RX_STAT(rx_no_bufs),
61 	ENIC_RX_STAT(rx_errors),
62 	ENIC_RX_STAT(rx_rss),
63 	ENIC_RX_STAT(rx_crc_errors),
64 	ENIC_RX_STAT(rx_frames_64),
65 	ENIC_RX_STAT(rx_frames_127),
66 	ENIC_RX_STAT(rx_frames_255),
67 	ENIC_RX_STAT(rx_frames_511),
68 	ENIC_RX_STAT(rx_frames_1023),
69 	ENIC_RX_STAT(rx_frames_1518),
70 	ENIC_RX_STAT(rx_frames_to_max),
71 };
72 
73 static const struct enic_stat enic_gen_stats[] = {
74 	ENIC_GEN_STAT(dma_map_error),
75 };
76 
77 static const unsigned int enic_n_tx_stats = ARRAY_SIZE(enic_tx_stats);
78 static const unsigned int enic_n_rx_stats = ARRAY_SIZE(enic_rx_stats);
79 static const unsigned int enic_n_gen_stats = ARRAY_SIZE(enic_gen_stats);
80 
81 static void enic_intr_coal_set_rx(struct enic *enic, u32 timer)
82 {
83 	int i;
84 	int intr;
85 
86 	for (i = 0; i < enic->rq_count; i++) {
87 		intr = enic_msix_rq_intr(enic, i);
88 		vnic_intr_coalescing_timer_set(&enic->intr[intr], timer);
89 	}
90 }
91 
92 static int enic_get_ksettings(struct net_device *netdev,
93 			      struct ethtool_link_ksettings *ecmd)
94 {
95 	struct enic *enic = netdev_priv(netdev);
96 	struct ethtool_link_settings *base = &ecmd->base;
97 
98 	ethtool_link_ksettings_add_link_mode(ecmd, supported,
99 					     10000baseT_Full);
100 	ethtool_link_ksettings_add_link_mode(ecmd, supported, FIBRE);
101 	ethtool_link_ksettings_add_link_mode(ecmd, advertising,
102 					     10000baseT_Full);
103 	ethtool_link_ksettings_add_link_mode(ecmd, advertising, FIBRE);
104 	base->port = PORT_FIBRE;
105 
106 	if (netif_carrier_ok(netdev)) {
107 		base->speed = vnic_dev_port_speed(enic->vdev);
108 		base->duplex = DUPLEX_FULL;
109 	} else {
110 		base->speed = SPEED_UNKNOWN;
111 		base->duplex = DUPLEX_UNKNOWN;
112 	}
113 
114 	base->autoneg = AUTONEG_DISABLE;
115 
116 	return 0;
117 }
118 
119 static void enic_get_drvinfo(struct net_device *netdev,
120 	struct ethtool_drvinfo *drvinfo)
121 {
122 	struct enic *enic = netdev_priv(netdev);
123 	struct vnic_devcmd_fw_info *fw_info;
124 	int err;
125 
126 	err = enic_dev_fw_info(enic, &fw_info);
127 	/* return only when dma_alloc_coherent fails in vnic_dev_fw_info
128 	 * For other failures, like devcmd failure, we return previously
129 	 * recorded info.
130 	 */
131 	if (err == -ENOMEM)
132 		return;
133 
134 	strscpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
135 	strscpy(drvinfo->fw_version, fw_info->fw_version,
136 		sizeof(drvinfo->fw_version));
137 	strscpy(drvinfo->bus_info, pci_name(enic->pdev),
138 		sizeof(drvinfo->bus_info));
139 }
140 
141 static void enic_get_strings(struct net_device *netdev, u32 stringset,
142 	u8 *data)
143 {
144 	unsigned int i;
145 
146 	switch (stringset) {
147 	case ETH_SS_STATS:
148 		for (i = 0; i < enic_n_tx_stats; i++) {
149 			memcpy(data, enic_tx_stats[i].name, ETH_GSTRING_LEN);
150 			data += ETH_GSTRING_LEN;
151 		}
152 		for (i = 0; i < enic_n_rx_stats; i++) {
153 			memcpy(data, enic_rx_stats[i].name, ETH_GSTRING_LEN);
154 			data += ETH_GSTRING_LEN;
155 		}
156 		for (i = 0; i < enic_n_gen_stats; i++) {
157 			memcpy(data, enic_gen_stats[i].name, ETH_GSTRING_LEN);
158 			data += ETH_GSTRING_LEN;
159 		}
160 		break;
161 	}
162 }
163 
164 static void enic_get_ringparam(struct net_device *netdev,
165 			       struct ethtool_ringparam *ring,
166 			       struct kernel_ethtool_ringparam *kernel_ring,
167 			       struct netlink_ext_ack *extack)
168 {
169 	struct enic *enic = netdev_priv(netdev);
170 	struct vnic_enet_config *c = &enic->config;
171 
172 	ring->rx_max_pending = ENIC_MAX_RQ_DESCS;
173 	ring->rx_pending = c->rq_desc_count;
174 	ring->tx_max_pending = ENIC_MAX_WQ_DESCS;
175 	ring->tx_pending = c->wq_desc_count;
176 }
177 
178 static int enic_set_ringparam(struct net_device *netdev,
179 			      struct ethtool_ringparam *ring,
180 			      struct kernel_ethtool_ringparam *kernel_ring,
181 			      struct netlink_ext_ack *extack)
182 {
183 	struct enic *enic = netdev_priv(netdev);
184 	struct vnic_enet_config *c = &enic->config;
185 	int running = netif_running(netdev);
186 	unsigned int rx_pending;
187 	unsigned int tx_pending;
188 	int err = 0;
189 
190 	if (ring->rx_mini_max_pending || ring->rx_mini_pending) {
191 		netdev_info(netdev,
192 			    "modifying mini ring params is not supported");
193 		return -EINVAL;
194 	}
195 	if (ring->rx_jumbo_max_pending || ring->rx_jumbo_pending) {
196 		netdev_info(netdev,
197 			    "modifying jumbo ring params is not supported");
198 		return -EINVAL;
199 	}
200 	rx_pending = c->rq_desc_count;
201 	tx_pending = c->wq_desc_count;
202 	if (ring->rx_pending > ENIC_MAX_RQ_DESCS ||
203 	    ring->rx_pending < ENIC_MIN_RQ_DESCS) {
204 		netdev_info(netdev, "rx pending (%u) not in range [%u,%u]",
205 			    ring->rx_pending, ENIC_MIN_RQ_DESCS,
206 			    ENIC_MAX_RQ_DESCS);
207 		return -EINVAL;
208 	}
209 	if (ring->tx_pending > ENIC_MAX_WQ_DESCS ||
210 	    ring->tx_pending < ENIC_MIN_WQ_DESCS) {
211 		netdev_info(netdev, "tx pending (%u) not in range [%u,%u]",
212 			    ring->tx_pending, ENIC_MIN_WQ_DESCS,
213 			    ENIC_MAX_WQ_DESCS);
214 		return -EINVAL;
215 	}
216 	if (running)
217 		dev_close(netdev);
218 	c->rq_desc_count =
219 		ring->rx_pending & 0xffffffe0; /* must be aligned to groups of 32 */
220 	c->wq_desc_count =
221 		ring->tx_pending & 0xffffffe0; /* must be aligned to groups of 32 */
222 	enic_free_vnic_resources(enic);
223 	err = enic_alloc_vnic_resources(enic);
224 	if (err) {
225 		netdev_err(netdev,
226 			   "Failed to alloc vNIC resources, aborting\n");
227 		enic_free_vnic_resources(enic);
228 		goto err_out;
229 	}
230 	enic_init_vnic_resources(enic);
231 	if (running) {
232 		err = dev_open(netdev, NULL);
233 		if (err)
234 			goto err_out;
235 	}
236 	return 0;
237 err_out:
238 	c->rq_desc_count = rx_pending;
239 	c->wq_desc_count = tx_pending;
240 	return err;
241 }
242 
243 static int enic_get_sset_count(struct net_device *netdev, int sset)
244 {
245 	switch (sset) {
246 	case ETH_SS_STATS:
247 		return enic_n_tx_stats + enic_n_rx_stats + enic_n_gen_stats;
248 	default:
249 		return -EOPNOTSUPP;
250 	}
251 }
252 
253 static void enic_get_ethtool_stats(struct net_device *netdev,
254 	struct ethtool_stats *stats, u64 *data)
255 {
256 	struct enic *enic = netdev_priv(netdev);
257 	struct vnic_stats *vstats;
258 	unsigned int i;
259 	int err;
260 
261 	err = enic_dev_stats_dump(enic, &vstats);
262 	/* return only when dma_alloc_coherent fails in vnic_dev_stats_dump
263 	 * For other failures, like devcmd failure, we return previously
264 	 * recorded stats.
265 	 */
266 	if (err == -ENOMEM)
267 		return;
268 
269 	for (i = 0; i < enic_n_tx_stats; i++)
270 		*(data++) = ((u64 *)&vstats->tx)[enic_tx_stats[i].index];
271 	for (i = 0; i < enic_n_rx_stats; i++)
272 		*(data++) = ((u64 *)&vstats->rx)[enic_rx_stats[i].index];
273 	for (i = 0; i < enic_n_gen_stats; i++)
274 		*(data++) = ((u64 *)&enic->gen_stats)[enic_gen_stats[i].index];
275 }
276 
277 static u32 enic_get_msglevel(struct net_device *netdev)
278 {
279 	struct enic *enic = netdev_priv(netdev);
280 	return enic->msg_enable;
281 }
282 
283 static void enic_set_msglevel(struct net_device *netdev, u32 value)
284 {
285 	struct enic *enic = netdev_priv(netdev);
286 	enic->msg_enable = value;
287 }
288 
289 static int enic_get_coalesce(struct net_device *netdev,
290 			     struct ethtool_coalesce *ecmd,
291 			     struct kernel_ethtool_coalesce *kernel_coal,
292 			     struct netlink_ext_ack *extack)
293 {
294 	struct enic *enic = netdev_priv(netdev);
295 	struct enic_rx_coal *rxcoal = &enic->rx_coalesce_setting;
296 
297 	if (vnic_dev_get_intr_mode(enic->vdev) == VNIC_DEV_INTR_MODE_MSIX)
298 		ecmd->tx_coalesce_usecs = enic->tx_coalesce_usecs;
299 	ecmd->rx_coalesce_usecs = enic->rx_coalesce_usecs;
300 	if (rxcoal->use_adaptive_rx_coalesce)
301 		ecmd->use_adaptive_rx_coalesce = 1;
302 	ecmd->rx_coalesce_usecs_low = rxcoal->small_pkt_range_start;
303 	ecmd->rx_coalesce_usecs_high = rxcoal->range_end;
304 
305 	return 0;
306 }
307 
308 static int enic_coalesce_valid(struct enic *enic,
309 			       struct ethtool_coalesce *ec)
310 {
311 	u32 coalesce_usecs_max = vnic_dev_get_intr_coal_timer_max(enic->vdev);
312 	u32 rx_coalesce_usecs_high = min_t(u32, coalesce_usecs_max,
313 					   ec->rx_coalesce_usecs_high);
314 	u32 rx_coalesce_usecs_low = min_t(u32, coalesce_usecs_max,
315 					  ec->rx_coalesce_usecs_low);
316 
317 	if ((vnic_dev_get_intr_mode(enic->vdev) != VNIC_DEV_INTR_MODE_MSIX) &&
318 	    ec->tx_coalesce_usecs)
319 		return -EINVAL;
320 
321 	if ((ec->tx_coalesce_usecs > coalesce_usecs_max)	||
322 	    (ec->rx_coalesce_usecs > coalesce_usecs_max)	||
323 	    (ec->rx_coalesce_usecs_low > coalesce_usecs_max)	||
324 	    (ec->rx_coalesce_usecs_high > coalesce_usecs_max))
325 		netdev_info(enic->netdev, "ethtool_set_coalesce: adaptor supports max coalesce value of %d. Setting max value.\n",
326 			    coalesce_usecs_max);
327 
328 	if (ec->rx_coalesce_usecs_high &&
329 	    (rx_coalesce_usecs_high <
330 	     rx_coalesce_usecs_low + ENIC_AIC_LARGE_PKT_DIFF))
331 		return -EINVAL;
332 
333 	return 0;
334 }
335 
336 static int enic_set_coalesce(struct net_device *netdev,
337 			     struct ethtool_coalesce *ecmd,
338 			     struct kernel_ethtool_coalesce *kernel_coal,
339 			     struct netlink_ext_ack *extack)
340 {
341 	struct enic *enic = netdev_priv(netdev);
342 	u32 tx_coalesce_usecs;
343 	u32 rx_coalesce_usecs;
344 	u32 rx_coalesce_usecs_low;
345 	u32 rx_coalesce_usecs_high;
346 	u32 coalesce_usecs_max;
347 	unsigned int i, intr;
348 	int ret;
349 	struct enic_rx_coal *rxcoal = &enic->rx_coalesce_setting;
350 
351 	ret = enic_coalesce_valid(enic, ecmd);
352 	if (ret)
353 		return ret;
354 	coalesce_usecs_max = vnic_dev_get_intr_coal_timer_max(enic->vdev);
355 	tx_coalesce_usecs = min_t(u32, ecmd->tx_coalesce_usecs,
356 				  coalesce_usecs_max);
357 	rx_coalesce_usecs = min_t(u32, ecmd->rx_coalesce_usecs,
358 				  coalesce_usecs_max);
359 
360 	rx_coalesce_usecs_low = min_t(u32, ecmd->rx_coalesce_usecs_low,
361 				      coalesce_usecs_max);
362 	rx_coalesce_usecs_high = min_t(u32, ecmd->rx_coalesce_usecs_high,
363 				       coalesce_usecs_max);
364 
365 	if (vnic_dev_get_intr_mode(enic->vdev) == VNIC_DEV_INTR_MODE_MSIX) {
366 		for (i = 0; i < enic->wq_count; i++) {
367 			intr = enic_msix_wq_intr(enic, i);
368 			vnic_intr_coalescing_timer_set(&enic->intr[intr],
369 						       tx_coalesce_usecs);
370 		}
371 		enic->tx_coalesce_usecs = tx_coalesce_usecs;
372 	}
373 	rxcoal->use_adaptive_rx_coalesce = !!ecmd->use_adaptive_rx_coalesce;
374 	if (!rxcoal->use_adaptive_rx_coalesce)
375 		enic_intr_coal_set_rx(enic, rx_coalesce_usecs);
376 	if (ecmd->rx_coalesce_usecs_high) {
377 		rxcoal->range_end = rx_coalesce_usecs_high;
378 		rxcoal->small_pkt_range_start = rx_coalesce_usecs_low;
379 		rxcoal->large_pkt_range_start = rx_coalesce_usecs_low +
380 						ENIC_AIC_LARGE_PKT_DIFF;
381 	}
382 
383 	enic->rx_coalesce_usecs = rx_coalesce_usecs;
384 
385 	return 0;
386 }
387 
388 static int enic_grxclsrlall(struct enic *enic, struct ethtool_rxnfc *cmd,
389 			    u32 *rule_locs)
390 {
391 	int j, ret = 0, cnt = 0;
392 
393 	cmd->data = enic->rfs_h.max - enic->rfs_h.free;
394 	for (j = 0; j < (1 << ENIC_RFS_FLW_BITSHIFT); j++) {
395 		struct hlist_head *hhead;
396 		struct hlist_node *tmp;
397 		struct enic_rfs_fltr_node *n;
398 
399 		hhead = &enic->rfs_h.ht_head[j];
400 		hlist_for_each_entry_safe(n, tmp, hhead, node) {
401 			if (cnt == cmd->rule_cnt)
402 				return -EMSGSIZE;
403 			rule_locs[cnt] = n->fltr_id;
404 			cnt++;
405 		}
406 	}
407 	cmd->rule_cnt = cnt;
408 
409 	return ret;
410 }
411 
412 static int enic_grxclsrule(struct enic *enic, struct ethtool_rxnfc *cmd)
413 {
414 	struct ethtool_rx_flow_spec *fsp =
415 				(struct ethtool_rx_flow_spec *)&cmd->fs;
416 	struct enic_rfs_fltr_node *n;
417 
418 	n = htbl_fltr_search(enic, (u16)fsp->location);
419 	if (!n)
420 		return -EINVAL;
421 	switch (n->keys.basic.ip_proto) {
422 	case IPPROTO_TCP:
423 		fsp->flow_type = TCP_V4_FLOW;
424 		break;
425 	case IPPROTO_UDP:
426 		fsp->flow_type = UDP_V4_FLOW;
427 		break;
428 	default:
429 		return -EINVAL;
430 	}
431 
432 	fsp->h_u.tcp_ip4_spec.ip4src = flow_get_u32_src(&n->keys);
433 	fsp->m_u.tcp_ip4_spec.ip4src = (__u32)~0;
434 
435 	fsp->h_u.tcp_ip4_spec.ip4dst = flow_get_u32_dst(&n->keys);
436 	fsp->m_u.tcp_ip4_spec.ip4dst = (__u32)~0;
437 
438 	fsp->h_u.tcp_ip4_spec.psrc = n->keys.ports.src;
439 	fsp->m_u.tcp_ip4_spec.psrc = (__u16)~0;
440 
441 	fsp->h_u.tcp_ip4_spec.pdst = n->keys.ports.dst;
442 	fsp->m_u.tcp_ip4_spec.pdst = (__u16)~0;
443 
444 	fsp->ring_cookie = n->rq_id;
445 
446 	return 0;
447 }
448 
449 static int enic_get_rx_flow_hash(struct enic *enic, struct ethtool_rxnfc *cmd)
450 {
451 	u8 rss_hash_type = 0;
452 	cmd->data = 0;
453 
454 	spin_lock_bh(&enic->devcmd_lock);
455 	(void)vnic_dev_capable_rss_hash_type(enic->vdev, &rss_hash_type);
456 	spin_unlock_bh(&enic->devcmd_lock);
457 	switch (cmd->flow_type) {
458 	case TCP_V6_FLOW:
459 	case TCP_V4_FLOW:
460 		cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3 |
461 			     RXH_IP_SRC | RXH_IP_DST;
462 		break;
463 	case UDP_V6_FLOW:
464 		cmd->data |= RXH_IP_SRC | RXH_IP_DST;
465 		if (rss_hash_type & NIC_CFG_RSS_HASH_TYPE_UDP_IPV6)
466 			cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
467 		break;
468 	case UDP_V4_FLOW:
469 		cmd->data |= RXH_IP_SRC | RXH_IP_DST;
470 		if (rss_hash_type & NIC_CFG_RSS_HASH_TYPE_UDP_IPV4)
471 			cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
472 		break;
473 	case SCTP_V4_FLOW:
474 	case AH_ESP_V4_FLOW:
475 	case AH_V4_FLOW:
476 	case ESP_V4_FLOW:
477 	case SCTP_V6_FLOW:
478 	case AH_ESP_V6_FLOW:
479 	case AH_V6_FLOW:
480 	case ESP_V6_FLOW:
481 	case IPV4_FLOW:
482 	case IPV6_FLOW:
483 		cmd->data |= RXH_IP_SRC | RXH_IP_DST;
484 		break;
485 	default:
486 		return -EINVAL;
487 	}
488 
489 	return 0;
490 }
491 
492 static int enic_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
493 			  u32 *rule_locs)
494 {
495 	struct enic *enic = netdev_priv(dev);
496 	int ret = 0;
497 
498 	switch (cmd->cmd) {
499 	case ETHTOOL_GRXRINGS:
500 		cmd->data = enic->rq_count;
501 		break;
502 	case ETHTOOL_GRXCLSRLCNT:
503 		spin_lock_bh(&enic->rfs_h.lock);
504 		cmd->rule_cnt = enic->rfs_h.max - enic->rfs_h.free;
505 		cmd->data = enic->rfs_h.max;
506 		spin_unlock_bh(&enic->rfs_h.lock);
507 		break;
508 	case ETHTOOL_GRXCLSRLALL:
509 		spin_lock_bh(&enic->rfs_h.lock);
510 		ret = enic_grxclsrlall(enic, cmd, rule_locs);
511 		spin_unlock_bh(&enic->rfs_h.lock);
512 		break;
513 	case ETHTOOL_GRXCLSRULE:
514 		spin_lock_bh(&enic->rfs_h.lock);
515 		ret = enic_grxclsrule(enic, cmd);
516 		spin_unlock_bh(&enic->rfs_h.lock);
517 		break;
518 	case ETHTOOL_GRXFH:
519 		ret = enic_get_rx_flow_hash(enic, cmd);
520 		break;
521 	default:
522 		ret = -EOPNOTSUPP;
523 		break;
524 	}
525 
526 	return ret;
527 }
528 
529 static int enic_get_tunable(struct net_device *dev,
530 			    const struct ethtool_tunable *tuna, void *data)
531 {
532 	struct enic *enic = netdev_priv(dev);
533 	int ret = 0;
534 
535 	switch (tuna->id) {
536 	case ETHTOOL_RX_COPYBREAK:
537 		*(u32 *)data = enic->rx_copybreak;
538 		break;
539 	default:
540 		ret = -EINVAL;
541 		break;
542 	}
543 
544 	return ret;
545 }
546 
547 static int enic_set_tunable(struct net_device *dev,
548 			    const struct ethtool_tunable *tuna,
549 			    const void *data)
550 {
551 	struct enic *enic = netdev_priv(dev);
552 	int ret = 0;
553 
554 	switch (tuna->id) {
555 	case ETHTOOL_RX_COPYBREAK:
556 		enic->rx_copybreak = *(u32 *)data;
557 		break;
558 	default:
559 		ret = -EINVAL;
560 		break;
561 	}
562 
563 	return ret;
564 }
565 
566 static u32 enic_get_rxfh_key_size(struct net_device *netdev)
567 {
568 	return ENIC_RSS_LEN;
569 }
570 
571 static int enic_get_rxfh(struct net_device *netdev, u32 *indir, u8 *hkey,
572 			 u8 *hfunc)
573 {
574 	struct enic *enic = netdev_priv(netdev);
575 
576 	if (hkey)
577 		memcpy(hkey, enic->rss_key, ENIC_RSS_LEN);
578 
579 	if (hfunc)
580 		*hfunc = ETH_RSS_HASH_TOP;
581 
582 	return 0;
583 }
584 
585 static int enic_set_rxfh(struct net_device *netdev, const u32 *indir,
586 			 const u8 *hkey, const u8 hfunc)
587 {
588 	struct enic *enic = netdev_priv(netdev);
589 
590 	if ((hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP) ||
591 	    indir)
592 		return -EINVAL;
593 
594 	if (hkey)
595 		memcpy(enic->rss_key, hkey, ENIC_RSS_LEN);
596 
597 	return __enic_set_rsskey(enic);
598 }
599 
600 static int enic_get_ts_info(struct net_device *netdev,
601 			    struct ethtool_ts_info *info)
602 {
603 	info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
604 				SOF_TIMESTAMPING_RX_SOFTWARE |
605 				SOF_TIMESTAMPING_SOFTWARE;
606 
607 	return 0;
608 }
609 
610 static const struct ethtool_ops enic_ethtool_ops = {
611 	.supported_coalesce_params = ETHTOOL_COALESCE_USECS |
612 				     ETHTOOL_COALESCE_USE_ADAPTIVE_RX |
613 				     ETHTOOL_COALESCE_RX_USECS_LOW |
614 				     ETHTOOL_COALESCE_RX_USECS_HIGH,
615 	.get_drvinfo = enic_get_drvinfo,
616 	.get_msglevel = enic_get_msglevel,
617 	.set_msglevel = enic_set_msglevel,
618 	.get_link = ethtool_op_get_link,
619 	.get_strings = enic_get_strings,
620 	.get_ringparam = enic_get_ringparam,
621 	.set_ringparam = enic_set_ringparam,
622 	.get_sset_count = enic_get_sset_count,
623 	.get_ethtool_stats = enic_get_ethtool_stats,
624 	.get_coalesce = enic_get_coalesce,
625 	.set_coalesce = enic_set_coalesce,
626 	.get_rxnfc = enic_get_rxnfc,
627 	.get_tunable = enic_get_tunable,
628 	.set_tunable = enic_set_tunable,
629 	.get_rxfh_key_size = enic_get_rxfh_key_size,
630 	.get_rxfh = enic_get_rxfh,
631 	.set_rxfh = enic_set_rxfh,
632 	.get_link_ksettings = enic_get_ksettings,
633 	.get_ts_info = enic_get_ts_info,
634 };
635 
636 void enic_set_ethtool_ops(struct net_device *netdev)
637 {
638 	netdev->ethtool_ops = &enic_ethtool_ops;
639 }
640