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