1 /* Intel Ethernet Switch Host Interface Driver
2 * Copyright(c) 2013 - 2014 Intel Corporation.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * The full GNU General Public License is included in this distribution in
14 * the file called "COPYING".
16 * Contact Information:
17 * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
18 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
21 #include <linux/vmalloc.h>
26 char stat_string
[ETH_GSTRING_LEN
];
31 #define FM10K_NETDEV_STAT(_net_stat) { \
32 .stat_string = #_net_stat, \
33 .sizeof_stat = FIELD_SIZEOF(struct net_device_stats, _net_stat), \
34 .stat_offset = offsetof(struct net_device_stats, _net_stat) \
37 static const struct fm10k_stats fm10k_gstrings_net_stats
[] = {
38 FM10K_NETDEV_STAT(tx_packets
),
39 FM10K_NETDEV_STAT(tx_bytes
),
40 FM10K_NETDEV_STAT(tx_errors
),
41 FM10K_NETDEV_STAT(rx_packets
),
42 FM10K_NETDEV_STAT(rx_bytes
),
43 FM10K_NETDEV_STAT(rx_errors
),
44 FM10K_NETDEV_STAT(rx_dropped
),
46 /* detailed Rx errors */
47 FM10K_NETDEV_STAT(rx_length_errors
),
48 FM10K_NETDEV_STAT(rx_crc_errors
),
49 FM10K_NETDEV_STAT(rx_fifo_errors
),
52 #define FM10K_NETDEV_STATS_LEN ARRAY_SIZE(fm10k_gstrings_net_stats)
54 #define FM10K_STAT(_name, _stat) { \
55 .stat_string = _name, \
56 .sizeof_stat = FIELD_SIZEOF(struct fm10k_intfc, _stat), \
57 .stat_offset = offsetof(struct fm10k_intfc, _stat) \
60 static const struct fm10k_stats fm10k_gstrings_stats
[] = {
61 FM10K_STAT("tx_restart_queue", restart_queue
),
62 FM10K_STAT("tx_busy", tx_busy
),
63 FM10K_STAT("tx_csum_errors", tx_csum_errors
),
64 FM10K_STAT("rx_alloc_failed", alloc_failed
),
65 FM10K_STAT("rx_csum_errors", rx_csum_errors
),
66 FM10K_STAT("rx_errors", rx_errors
),
68 FM10K_STAT("tx_packets_nic", tx_packets_nic
),
69 FM10K_STAT("tx_bytes_nic", tx_bytes_nic
),
70 FM10K_STAT("rx_packets_nic", rx_packets_nic
),
71 FM10K_STAT("rx_bytes_nic", rx_bytes_nic
),
72 FM10K_STAT("rx_drops_nic", rx_drops_nic
),
73 FM10K_STAT("rx_overrun_pf", rx_overrun_pf
),
74 FM10K_STAT("rx_overrun_vf", rx_overrun_vf
),
76 FM10K_STAT("timeout", stats
.timeout
.count
),
77 FM10K_STAT("ur", stats
.ur
.count
),
78 FM10K_STAT("ca", stats
.ca
.count
),
79 FM10K_STAT("um", stats
.um
.count
),
80 FM10K_STAT("xec", stats
.xec
.count
),
81 FM10K_STAT("vlan_drop", stats
.vlan_drop
.count
),
82 FM10K_STAT("loopback_drop", stats
.loopback_drop
.count
),
83 FM10K_STAT("nodesc_drop", stats
.nodesc_drop
.count
),
85 FM10K_STAT("swapi_status", hw
.swapi
.status
),
86 FM10K_STAT("mac_rules_used", hw
.swapi
.mac
.used
),
87 FM10K_STAT("mac_rules_avail", hw
.swapi
.mac
.avail
),
89 FM10K_STAT("mbx_tx_busy", hw
.mbx
.tx_busy
),
90 FM10K_STAT("mbx_tx_dropped", hw
.mbx
.tx_dropped
),
91 FM10K_STAT("mbx_tx_messages", hw
.mbx
.tx_messages
),
92 FM10K_STAT("mbx_tx_dwords", hw
.mbx
.tx_dwords
),
93 FM10K_STAT("mbx_rx_messages", hw
.mbx
.rx_messages
),
94 FM10K_STAT("mbx_rx_dwords", hw
.mbx
.rx_dwords
),
95 FM10K_STAT("mbx_rx_parse_err", hw
.mbx
.rx_parse_err
),
97 FM10K_STAT("tx_hwtstamp_timeouts", tx_hwtstamp_timeouts
),
100 #define FM10K_GLOBAL_STATS_LEN ARRAY_SIZE(fm10k_gstrings_stats)
102 #define FM10K_QUEUE_STATS_LEN \
103 (MAX_QUEUES * 2 * (sizeof(struct fm10k_queue_stats) / sizeof(u64)))
105 #define FM10K_STATS_LEN (FM10K_GLOBAL_STATS_LEN + \
106 FM10K_NETDEV_STATS_LEN + \
107 FM10K_QUEUE_STATS_LEN)
109 static const char fm10k_gstrings_test
[][ETH_GSTRING_LEN
] = {
110 "Mailbox test (on/offline)"
113 #define FM10K_TEST_LEN (sizeof(fm10k_gstrings_test) / ETH_GSTRING_LEN)
115 enum fm10k_self_test_types
{
117 FM10K_TEST_MAX
= FM10K_TEST_LEN
120 static void fm10k_get_strings(struct net_device
*dev
, u32 stringset
,
123 char *p
= (char *)data
;
128 memcpy(data
, *fm10k_gstrings_test
,
129 FM10K_TEST_LEN
* ETH_GSTRING_LEN
);
132 for (i
= 0; i
< FM10K_NETDEV_STATS_LEN
; i
++) {
133 memcpy(p
, fm10k_gstrings_net_stats
[i
].stat_string
,
135 p
+= ETH_GSTRING_LEN
;
137 for (i
= 0; i
< FM10K_GLOBAL_STATS_LEN
; i
++) {
138 memcpy(p
, fm10k_gstrings_stats
[i
].stat_string
,
140 p
+= ETH_GSTRING_LEN
;
143 for (i
= 0; i
< MAX_QUEUES
; i
++) {
144 sprintf(p
, "tx_queue_%u_packets", i
);
145 p
+= ETH_GSTRING_LEN
;
146 sprintf(p
, "tx_queue_%u_bytes", i
);
147 p
+= ETH_GSTRING_LEN
;
148 sprintf(p
, "rx_queue_%u_packets", i
);
149 p
+= ETH_GSTRING_LEN
;
150 sprintf(p
, "rx_queue_%u_bytes", i
);
151 p
+= ETH_GSTRING_LEN
;
157 static int fm10k_get_sset_count(struct net_device
*dev
, int sset
)
161 return FM10K_TEST_LEN
;
163 return FM10K_STATS_LEN
;
169 static void fm10k_get_ethtool_stats(struct net_device
*netdev
,
170 struct ethtool_stats
*stats
, u64
*data
)
172 const int stat_count
= sizeof(struct fm10k_queue_stats
) / sizeof(u64
);
173 struct fm10k_intfc
*interface
= netdev_priv(netdev
);
174 struct net_device_stats
*net_stats
= &netdev
->stats
;
178 fm10k_update_stats(interface
);
180 for (i
= 0; i
< FM10K_NETDEV_STATS_LEN
; i
++) {
181 p
= (char *)net_stats
+ fm10k_gstrings_net_stats
[i
].stat_offset
;
182 *(data
++) = (fm10k_gstrings_net_stats
[i
].sizeof_stat
==
183 sizeof(u64
)) ? *(u64
*)p
: *(u32
*)p
;
186 for (i
= 0; i
< FM10K_GLOBAL_STATS_LEN
; i
++) {
187 p
= (char *)interface
+ fm10k_gstrings_stats
[i
].stat_offset
;
188 *(data
++) = (fm10k_gstrings_stats
[i
].sizeof_stat
==
189 sizeof(u64
)) ? *(u64
*)p
: *(u32
*)p
;
192 for (i
= 0; i
< MAX_QUEUES
; i
++) {
193 struct fm10k_ring
*ring
;
196 ring
= interface
->tx_ring
[i
];
198 queue_stat
= (u64
*)&ring
->stats
;
199 for (j
= 0; j
< stat_count
; j
++)
200 *(data
++) = ring
? queue_stat
[j
] : 0;
202 ring
= interface
->rx_ring
[i
];
204 queue_stat
= (u64
*)&ring
->stats
;
205 for (j
= 0; j
< stat_count
; j
++)
206 *(data
++) = ring
? queue_stat
[j
] : 0;
210 /* If function below adds more registers this define needs to be updated */
211 #define FM10K_REGS_LEN_Q 29
213 static void fm10k_get_reg_q(struct fm10k_hw
*hw
, u32
*buff
, int i
)
217 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_RDBAL(i
));
218 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_RDBAH(i
));
219 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_RDLEN(i
));
220 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_TPH_RXCTRL(i
));
221 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_RDH(i
));
222 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_RDT(i
));
223 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_RXQCTL(i
));
224 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_RXDCTL(i
));
225 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_RXINT(i
));
226 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_SRRCTL(i
));
227 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_QPRC(i
));
228 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_QPRDC(i
));
229 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_QBRC_L(i
));
230 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_QBRC_H(i
));
231 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_TDBAL(i
));
232 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_TDBAH(i
));
233 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_TDLEN(i
));
234 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_TPH_TXCTRL(i
));
235 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_TDH(i
));
236 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_TDT(i
));
237 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_TXDCTL(i
));
238 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_TXQCTL(i
));
239 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_TXINT(i
));
240 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_QPTC(i
));
241 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_QBTC_L(i
));
242 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_QBTC_H(i
));
243 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_TQDLOC(i
));
244 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_TX_SGLORT(i
));
245 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_PFVTCTL(i
));
247 BUG_ON(idx
!= FM10K_REGS_LEN_Q
);
250 /* If function above adds more registers this define needs to be updated */
251 #define FM10K_REGS_LEN_VSI 43
253 static void fm10k_get_reg_vsi(struct fm10k_hw
*hw
, u32
*buff
, int i
)
257 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_MRQC(i
));
258 for (j
= 0; j
< 10; j
++)
259 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_RSSRK(i
, j
));
260 for (j
= 0; j
< 32; j
++)
261 buff
[idx
++] = fm10k_read_reg(hw
, FM10K_RETA(i
, j
));
263 BUG_ON(idx
!= FM10K_REGS_LEN_VSI
);
266 static void fm10k_get_regs(struct net_device
*netdev
,
267 struct ethtool_regs
*regs
, void *p
)
269 struct fm10k_intfc
*interface
= netdev_priv(netdev
);
270 struct fm10k_hw
*hw
= &interface
->hw
;
274 regs
->version
= (1 << 24) | (hw
->revision_id
<< 16) | hw
->device_id
;
276 switch (hw
->mac
.type
) {
278 /* General PF Registers */
279 *(buff
++) = fm10k_read_reg(hw
, FM10K_CTRL
);
280 *(buff
++) = fm10k_read_reg(hw
, FM10K_CTRL_EXT
);
281 *(buff
++) = fm10k_read_reg(hw
, FM10K_GCR
);
282 *(buff
++) = fm10k_read_reg(hw
, FM10K_GCR_EXT
);
284 for (i
= 0; i
< 8; i
++) {
285 *(buff
++) = fm10k_read_reg(hw
, FM10K_DGLORTMAP(i
));
286 *(buff
++) = fm10k_read_reg(hw
, FM10K_DGLORTDEC(i
));
289 for (i
= 0; i
< 65; i
++) {
290 fm10k_get_reg_vsi(hw
, buff
, i
);
291 buff
+= FM10K_REGS_LEN_VSI
;
294 *(buff
++) = fm10k_read_reg(hw
, FM10K_DMA_CTRL
);
295 *(buff
++) = fm10k_read_reg(hw
, FM10K_DMA_CTRL2
);
297 for (i
= 0; i
< FM10K_MAX_QUEUES_PF
; i
++) {
298 fm10k_get_reg_q(hw
, buff
, i
);
299 buff
+= FM10K_REGS_LEN_Q
;
302 *(buff
++) = fm10k_read_reg(hw
, FM10K_TPH_CTRL
);
304 for (i
= 0; i
< 8; i
++)
305 *(buff
++) = fm10k_read_reg(hw
, FM10K_INT_MAP(i
));
307 /* Interrupt Throttling Registers */
308 for (i
= 0; i
< 130; i
++)
309 *(buff
++) = fm10k_read_reg(hw
, FM10K_ITR(i
));
313 /* General VF registers */
314 *(buff
++) = fm10k_read_reg(hw
, FM10K_VFCTRL
);
315 *(buff
++) = fm10k_read_reg(hw
, FM10K_VFINT_MAP
);
316 *(buff
++) = fm10k_read_reg(hw
, FM10K_VFSYSTIME
);
318 /* Interrupt Throttling Registers */
319 for (i
= 0; i
< 8; i
++)
320 *(buff
++) = fm10k_read_reg(hw
, FM10K_VFITR(i
));
322 fm10k_get_reg_vsi(hw
, buff
, 0);
323 buff
+= FM10K_REGS_LEN_VSI
;
325 for (i
= 0; i
< FM10K_MAX_QUEUES_POOL
; i
++) {
326 if (i
< hw
->mac
.max_queues
)
327 fm10k_get_reg_q(hw
, buff
, i
);
329 memset(buff
, 0, sizeof(u32
) * FM10K_REGS_LEN_Q
);
330 buff
+= FM10K_REGS_LEN_Q
;
339 /* If function above adds more registers these define need to be updated */
340 #define FM10K_REGS_LEN_PF \
341 (162 + (65 * FM10K_REGS_LEN_VSI) + (FM10K_MAX_QUEUES_PF * FM10K_REGS_LEN_Q))
342 #define FM10K_REGS_LEN_VF \
343 (11 + FM10K_REGS_LEN_VSI + (FM10K_MAX_QUEUES_POOL * FM10K_REGS_LEN_Q))
345 static int fm10k_get_regs_len(struct net_device
*netdev
)
347 struct fm10k_intfc
*interface
= netdev_priv(netdev
);
348 struct fm10k_hw
*hw
= &interface
->hw
;
350 switch (hw
->mac
.type
) {
352 return FM10K_REGS_LEN_PF
* sizeof(u32
);
354 return FM10K_REGS_LEN_VF
* sizeof(u32
);
360 static void fm10k_get_drvinfo(struct net_device
*dev
,
361 struct ethtool_drvinfo
*info
)
363 struct fm10k_intfc
*interface
= netdev_priv(dev
);
365 strncpy(info
->driver
, fm10k_driver_name
,
366 sizeof(info
->driver
) - 1);
367 strncpy(info
->version
, fm10k_driver_version
,
368 sizeof(info
->version
) - 1);
369 strncpy(info
->bus_info
, pci_name(interface
->pdev
),
370 sizeof(info
->bus_info
) - 1);
372 info
->n_stats
= FM10K_STATS_LEN
;
374 info
->regdump_len
= fm10k_get_regs_len(dev
);
377 static void fm10k_get_pauseparam(struct net_device
*dev
,
378 struct ethtool_pauseparam
*pause
)
380 struct fm10k_intfc
*interface
= netdev_priv(dev
);
382 /* record fixed values for autoneg and tx pause */
386 pause
->rx_pause
= interface
->rx_pause
? 1 : 0;
389 static int fm10k_set_pauseparam(struct net_device
*dev
,
390 struct ethtool_pauseparam
*pause
)
392 struct fm10k_intfc
*interface
= netdev_priv(dev
);
393 struct fm10k_hw
*hw
= &interface
->hw
;
395 if (pause
->autoneg
|| !pause
->tx_pause
)
398 /* we can only support pause on the PF to avoid head-of-line blocking */
399 if (hw
->mac
.type
== fm10k_mac_pf
)
400 interface
->rx_pause
= pause
->rx_pause
? ~0 : 0;
401 else if (pause
->rx_pause
)
404 if (netif_running(dev
))
405 fm10k_update_rx_drop_en(interface
);
410 static u32
fm10k_get_msglevel(struct net_device
*netdev
)
412 struct fm10k_intfc
*interface
= netdev_priv(netdev
);
414 return interface
->msg_enable
;
417 static void fm10k_set_msglevel(struct net_device
*netdev
, u32 data
)
419 struct fm10k_intfc
*interface
= netdev_priv(netdev
);
421 interface
->msg_enable
= data
;
424 static void fm10k_get_ringparam(struct net_device
*netdev
,
425 struct ethtool_ringparam
*ring
)
427 struct fm10k_intfc
*interface
= netdev_priv(netdev
);
429 ring
->rx_max_pending
= FM10K_MAX_RXD
;
430 ring
->tx_max_pending
= FM10K_MAX_TXD
;
431 ring
->rx_mini_max_pending
= 0;
432 ring
->rx_jumbo_max_pending
= 0;
433 ring
->rx_pending
= interface
->rx_ring_count
;
434 ring
->tx_pending
= interface
->tx_ring_count
;
435 ring
->rx_mini_pending
= 0;
436 ring
->rx_jumbo_pending
= 0;
439 static int fm10k_set_ringparam(struct net_device
*netdev
,
440 struct ethtool_ringparam
*ring
)
442 struct fm10k_intfc
*interface
= netdev_priv(netdev
);
443 struct fm10k_ring
*temp_ring
;
445 u32 new_rx_count
, new_tx_count
;
447 if ((ring
->rx_mini_pending
) || (ring
->rx_jumbo_pending
))
450 new_tx_count
= clamp_t(u32
, ring
->tx_pending
,
451 FM10K_MIN_TXD
, FM10K_MAX_TXD
);
452 new_tx_count
= ALIGN(new_tx_count
, FM10K_REQ_TX_DESCRIPTOR_MULTIPLE
);
454 new_rx_count
= clamp_t(u32
, ring
->rx_pending
,
455 FM10K_MIN_RXD
, FM10K_MAX_RXD
);
456 new_rx_count
= ALIGN(new_rx_count
, FM10K_REQ_RX_DESCRIPTOR_MULTIPLE
);
458 if ((new_tx_count
== interface
->tx_ring_count
) &&
459 (new_rx_count
== interface
->rx_ring_count
)) {
464 while (test_and_set_bit(__FM10K_RESETTING
, &interface
->state
))
465 usleep_range(1000, 2000);
467 if (!netif_running(interface
->netdev
)) {
468 for (i
= 0; i
< interface
->num_tx_queues
; i
++)
469 interface
->tx_ring
[i
]->count
= new_tx_count
;
470 for (i
= 0; i
< interface
->num_rx_queues
; i
++)
471 interface
->rx_ring
[i
]->count
= new_rx_count
;
472 interface
->tx_ring_count
= new_tx_count
;
473 interface
->rx_ring_count
= new_rx_count
;
477 /* allocate temporary buffer to store rings in */
478 i
= max_t(int, interface
->num_tx_queues
, interface
->num_rx_queues
);
479 temp_ring
= vmalloc(i
* sizeof(struct fm10k_ring
));
486 fm10k_down(interface
);
488 /* Setup new Tx resources and free the old Tx resources in that order.
489 * We can then assign the new resources to the rings via a memcpy.
490 * The advantage to this approach is that we are guaranteed to still
491 * have resources even in the case of an allocation failure.
493 if (new_tx_count
!= interface
->tx_ring_count
) {
494 for (i
= 0; i
< interface
->num_tx_queues
; i
++) {
495 memcpy(&temp_ring
[i
], interface
->tx_ring
[i
],
496 sizeof(struct fm10k_ring
));
498 temp_ring
[i
].count
= new_tx_count
;
499 err
= fm10k_setup_tx_resources(&temp_ring
[i
]);
503 fm10k_free_tx_resources(&temp_ring
[i
]);
509 for (i
= 0; i
< interface
->num_tx_queues
; i
++) {
510 fm10k_free_tx_resources(interface
->tx_ring
[i
]);
512 memcpy(interface
->tx_ring
[i
], &temp_ring
[i
],
513 sizeof(struct fm10k_ring
));
516 interface
->tx_ring_count
= new_tx_count
;
519 /* Repeat the process for the Rx rings if needed */
520 if (new_rx_count
!= interface
->rx_ring_count
) {
521 for (i
= 0; i
< interface
->num_rx_queues
; i
++) {
522 memcpy(&temp_ring
[i
], interface
->rx_ring
[i
],
523 sizeof(struct fm10k_ring
));
525 temp_ring
[i
].count
= new_rx_count
;
526 err
= fm10k_setup_rx_resources(&temp_ring
[i
]);
530 fm10k_free_rx_resources(&temp_ring
[i
]);
536 for (i
= 0; i
< interface
->num_rx_queues
; i
++) {
537 fm10k_free_rx_resources(interface
->rx_ring
[i
]);
539 memcpy(interface
->rx_ring
[i
], &temp_ring
[i
],
540 sizeof(struct fm10k_ring
));
543 interface
->rx_ring_count
= new_rx_count
;
550 clear_bit(__FM10K_RESETTING
, &interface
->state
);
554 static int fm10k_get_coalesce(struct net_device
*dev
,
555 struct ethtool_coalesce
*ec
)
557 struct fm10k_intfc
*interface
= netdev_priv(dev
);
559 ec
->use_adaptive_tx_coalesce
=
560 !!(interface
->tx_itr
& FM10K_ITR_ADAPTIVE
);
561 ec
->tx_coalesce_usecs
= interface
->tx_itr
& ~FM10K_ITR_ADAPTIVE
;
563 ec
->use_adaptive_rx_coalesce
=
564 !!(interface
->rx_itr
& FM10K_ITR_ADAPTIVE
);
565 ec
->rx_coalesce_usecs
= interface
->rx_itr
& ~FM10K_ITR_ADAPTIVE
;
570 static int fm10k_set_coalesce(struct net_device
*dev
,
571 struct ethtool_coalesce
*ec
)
573 struct fm10k_intfc
*interface
= netdev_priv(dev
);
574 struct fm10k_q_vector
*qv
;
579 if ((ec
->rx_coalesce_usecs
> FM10K_ITR_MAX
) ||
580 (ec
->tx_coalesce_usecs
> FM10K_ITR_MAX
))
583 /* record settings */
584 tx_itr
= ec
->tx_coalesce_usecs
;
585 rx_itr
= ec
->rx_coalesce_usecs
;
587 /* set initial values for adaptive ITR */
588 if (ec
->use_adaptive_tx_coalesce
)
589 tx_itr
= FM10K_ITR_ADAPTIVE
| FM10K_ITR_10K
;
591 if (ec
->use_adaptive_rx_coalesce
)
592 rx_itr
= FM10K_ITR_ADAPTIVE
| FM10K_ITR_20K
;
594 /* update interface */
595 interface
->tx_itr
= tx_itr
;
596 interface
->rx_itr
= rx_itr
;
598 /* update q_vectors */
599 for (i
= 0; i
< interface
->num_q_vectors
; i
++) {
600 qv
= interface
->q_vector
[i
];
608 static int fm10k_get_rss_hash_opts(struct fm10k_intfc
*interface
,
609 struct ethtool_rxnfc
*cmd
)
613 /* Report default options for RSS on fm10k */
614 switch (cmd
->flow_type
) {
617 cmd
->data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
620 if (interface
->flags
& FM10K_FLAG_RSS_FIELD_IPV4_UDP
)
621 cmd
->data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
633 cmd
->data
|= RXH_IP_SRC
| RXH_IP_DST
;
636 if (interface
->flags
& FM10K_FLAG_RSS_FIELD_IPV6_UDP
)
637 cmd
->data
|= RXH_L4_B_0_1
| RXH_L4_B_2_3
;
638 cmd
->data
|= RXH_IP_SRC
| RXH_IP_DST
;
647 static int fm10k_get_rxnfc(struct net_device
*dev
, struct ethtool_rxnfc
*cmd
,
650 struct fm10k_intfc
*interface
= netdev_priv(dev
);
651 int ret
= -EOPNOTSUPP
;
654 case ETHTOOL_GRXRINGS
:
655 cmd
->data
= interface
->num_rx_queues
;
659 ret
= fm10k_get_rss_hash_opts(interface
, cmd
);
668 #define UDP_RSS_FLAGS (FM10K_FLAG_RSS_FIELD_IPV4_UDP | \
669 FM10K_FLAG_RSS_FIELD_IPV6_UDP)
670 static int fm10k_set_rss_hash_opt(struct fm10k_intfc
*interface
,
671 struct ethtool_rxnfc
*nfc
)
673 u32 flags
= interface
->flags
;
675 /* RSS does not support anything other than hashing
676 * to queues on src and dst IPs and ports
678 if (nfc
->data
& ~(RXH_IP_SRC
| RXH_IP_DST
|
679 RXH_L4_B_0_1
| RXH_L4_B_2_3
))
682 switch (nfc
->flow_type
) {
685 if (!(nfc
->data
& RXH_IP_SRC
) ||
686 !(nfc
->data
& RXH_IP_DST
) ||
687 !(nfc
->data
& RXH_L4_B_0_1
) ||
688 !(nfc
->data
& RXH_L4_B_2_3
))
692 if (!(nfc
->data
& RXH_IP_SRC
) ||
693 !(nfc
->data
& RXH_IP_DST
))
695 switch (nfc
->data
& (RXH_L4_B_0_1
| RXH_L4_B_2_3
)) {
697 flags
&= ~FM10K_FLAG_RSS_FIELD_IPV4_UDP
;
699 case (RXH_L4_B_0_1
| RXH_L4_B_2_3
):
700 flags
|= FM10K_FLAG_RSS_FIELD_IPV4_UDP
;
707 if (!(nfc
->data
& RXH_IP_SRC
) ||
708 !(nfc
->data
& RXH_IP_DST
))
710 switch (nfc
->data
& (RXH_L4_B_0_1
| RXH_L4_B_2_3
)) {
712 flags
&= ~FM10K_FLAG_RSS_FIELD_IPV6_UDP
;
714 case (RXH_L4_B_0_1
| RXH_L4_B_2_3
):
715 flags
|= FM10K_FLAG_RSS_FIELD_IPV6_UDP
;
729 if (!(nfc
->data
& RXH_IP_SRC
) ||
730 !(nfc
->data
& RXH_IP_DST
) ||
731 (nfc
->data
& RXH_L4_B_0_1
) ||
732 (nfc
->data
& RXH_L4_B_2_3
))
739 /* if we changed something we need to update flags */
740 if (flags
!= interface
->flags
) {
741 struct fm10k_hw
*hw
= &interface
->hw
;
744 if ((flags
& UDP_RSS_FLAGS
) &&
745 !(interface
->flags
& UDP_RSS_FLAGS
))
746 netif_warn(interface
, drv
, interface
->netdev
,
747 "enabling UDP RSS: fragmented packets may arrive out of order to the stack above\n");
749 interface
->flags
= flags
;
751 /* Perform hash on these packet types */
752 mrqc
= FM10K_MRQC_IPV4
|
753 FM10K_MRQC_TCP_IPV4
|
757 if (flags
& FM10K_FLAG_RSS_FIELD_IPV4_UDP
)
758 mrqc
|= FM10K_MRQC_UDP_IPV4
;
759 if (flags
& FM10K_FLAG_RSS_FIELD_IPV6_UDP
)
760 mrqc
|= FM10K_MRQC_UDP_IPV6
;
762 fm10k_write_reg(hw
, FM10K_MRQC(0), mrqc
);
768 static int fm10k_set_rxnfc(struct net_device
*dev
, struct ethtool_rxnfc
*cmd
)
770 struct fm10k_intfc
*interface
= netdev_priv(dev
);
771 int ret
= -EOPNOTSUPP
;
775 ret
= fm10k_set_rss_hash_opt(interface
, cmd
);
784 static int fm10k_mbx_test(struct fm10k_intfc
*interface
, u64
*data
)
786 struct fm10k_hw
*hw
= &interface
->hw
;
787 struct fm10k_mbx_info
*mbx
= &hw
->mbx
;
788 u32 attr_flag
, test_msg
[6];
789 unsigned long timeout
;
792 /* For now this is a VF only feature */
793 if (hw
->mac
.type
!= fm10k_mac_vf
)
796 /* loop through both nested and unnested attribute types */
797 for (attr_flag
= (1 << FM10K_TEST_MSG_UNSET
);
798 attr_flag
< (1 << (2 * FM10K_TEST_MSG_NESTED
));
799 attr_flag
+= attr_flag
) {
800 /* generate message to be tested */
801 fm10k_tlv_msg_test_create(test_msg
, attr_flag
);
803 fm10k_mbx_lock(interface
);
804 mbx
->test_result
= FM10K_NOT_IMPLEMENTED
;
805 err
= mbx
->ops
.enqueue_tx(hw
, mbx
, test_msg
);
806 fm10k_mbx_unlock(interface
);
808 /* wait up to 1 second for response */
809 timeout
= jiffies
+ HZ
;
814 usleep_range(500, 1000);
816 fm10k_mbx_lock(interface
);
817 mbx
->ops
.process(hw
, mbx
);
818 fm10k_mbx_unlock(interface
);
820 err
= mbx
->test_result
;
823 } while (time_is_after_jiffies(timeout
));
825 /* reporting errors */
831 *data
= err
< 0 ? (attr_flag
) : (err
> 0);
835 static void fm10k_self_test(struct net_device
*dev
,
836 struct ethtool_test
*eth_test
, u64
*data
)
838 struct fm10k_intfc
*interface
= netdev_priv(dev
);
839 struct fm10k_hw
*hw
= &interface
->hw
;
841 memset(data
, 0, sizeof(*data
) * FM10K_TEST_LEN
);
843 if (FM10K_REMOVED(hw
)) {
844 netif_err(interface
, drv
, dev
,
845 "Interface removed - test blocked\n");
846 eth_test
->flags
|= ETH_TEST_FL_FAILED
;
850 if (fm10k_mbx_test(interface
, &data
[FM10K_TEST_MBX
]))
851 eth_test
->flags
|= ETH_TEST_FL_FAILED
;
854 static u32
fm10k_get_reta_size(struct net_device
*netdev
)
856 return FM10K_RETA_SIZE
* FM10K_RETA_ENTRIES_PER_REG
;
859 static int fm10k_get_reta(struct net_device
*netdev
, u32
*indir
)
861 struct fm10k_intfc
*interface
= netdev_priv(netdev
);
867 for (i
= 0; i
< FM10K_RETA_SIZE
; i
++, indir
+= 4) {
868 u32 reta
= interface
->reta
[i
];
870 indir
[0] = (reta
<< 24) >> 24;
871 indir
[1] = (reta
<< 16) >> 24;
872 indir
[2] = (reta
<< 8) >> 24;
873 indir
[3] = (reta
) >> 24;
879 static int fm10k_set_reta(struct net_device
*netdev
, const u32
*indir
)
881 struct fm10k_intfc
*interface
= netdev_priv(netdev
);
882 struct fm10k_hw
*hw
= &interface
->hw
;
889 /* Verify user input. */
890 rss_i
= interface
->ring_feature
[RING_F_RSS
].indices
;
891 for (i
= fm10k_get_reta_size(netdev
); i
--;) {
892 if (indir
[i
] < rss_i
)
897 /* record entries to reta table */
898 for (i
= 0; i
< FM10K_RETA_SIZE
; i
++, indir
+= 4) {
899 u32 reta
= indir
[0] |
904 if (interface
->reta
[i
] == reta
)
907 interface
->reta
[i
] = reta
;
908 fm10k_write_reg(hw
, FM10K_RETA(0, i
), reta
);
914 static u32
fm10k_get_rssrk_size(struct net_device
*netdev
)
916 return FM10K_RSSRK_SIZE
* FM10K_RSSRK_ENTRIES_PER_REG
;
919 static int fm10k_get_rssh(struct net_device
*netdev
, u32
*indir
, u8
*key
,
922 struct fm10k_intfc
*interface
= netdev_priv(netdev
);
926 *hfunc
= ETH_RSS_HASH_TOP
;
928 err
= fm10k_get_reta(netdev
, indir
);
932 for (i
= 0; i
< FM10K_RSSRK_SIZE
; i
++, key
+= 4)
933 *(__le32
*)key
= cpu_to_le32(interface
->rssrk
[i
]);
938 static int fm10k_set_rssh(struct net_device
*netdev
, const u32
*indir
,
939 const u8
*key
, const u8 hfunc
)
941 struct fm10k_intfc
*interface
= netdev_priv(netdev
);
942 struct fm10k_hw
*hw
= &interface
->hw
;
945 /* We do not allow change in unsupported parameters */
946 if (hfunc
!= ETH_RSS_HASH_NO_CHANGE
&& hfunc
!= ETH_RSS_HASH_TOP
)
949 err
= fm10k_set_reta(netdev
, indir
);
953 for (i
= 0; i
< FM10K_RSSRK_SIZE
; i
++, key
+= 4) {
954 u32 rssrk
= le32_to_cpu(*(__le32
*)key
);
956 if (interface
->rssrk
[i
] == rssrk
)
959 interface
->rssrk
[i
] = rssrk
;
960 fm10k_write_reg(hw
, FM10K_RSSRK(0, i
), rssrk
);
966 static unsigned int fm10k_max_channels(struct net_device
*dev
)
968 struct fm10k_intfc
*interface
= netdev_priv(dev
);
969 unsigned int max_combined
= interface
->hw
.mac
.max_queues
;
970 u8 tcs
= netdev_get_num_tc(dev
);
972 /* For QoS report channels per traffic class */
974 max_combined
= 1 << (fls(max_combined
/ tcs
) - 1);
979 static void fm10k_get_channels(struct net_device
*dev
,
980 struct ethtool_channels
*ch
)
982 struct fm10k_intfc
*interface
= netdev_priv(dev
);
983 struct fm10k_hw
*hw
= &interface
->hw
;
985 /* report maximum channels */
986 ch
->max_combined
= fm10k_max_channels(dev
);
988 /* report info for other vector */
989 ch
->max_other
= NON_Q_VECTORS(hw
);
990 ch
->other_count
= ch
->max_other
;
992 /* record RSS queues */
993 ch
->combined_count
= interface
->ring_feature
[RING_F_RSS
].indices
;
996 static int fm10k_set_channels(struct net_device
*dev
,
997 struct ethtool_channels
*ch
)
999 struct fm10k_intfc
*interface
= netdev_priv(dev
);
1000 unsigned int count
= ch
->combined_count
;
1001 struct fm10k_hw
*hw
= &interface
->hw
;
1003 /* verify they are not requesting separate vectors */
1004 if (!count
|| ch
->rx_count
|| ch
->tx_count
)
1007 /* verify other_count has not changed */
1008 if (ch
->other_count
!= NON_Q_VECTORS(hw
))
1011 /* verify the number of channels does not exceed hardware limits */
1012 if (count
> fm10k_max_channels(dev
))
1015 interface
->ring_feature
[RING_F_RSS
].limit
= count
;
1017 /* use setup TC to update any traffic class queue mapping */
1018 return fm10k_setup_tc(dev
, netdev_get_num_tc(dev
));
1021 static int fm10k_get_ts_info(struct net_device
*dev
,
1022 struct ethtool_ts_info
*info
)
1024 struct fm10k_intfc
*interface
= netdev_priv(dev
);
1026 info
->so_timestamping
=
1027 SOF_TIMESTAMPING_TX_SOFTWARE
|
1028 SOF_TIMESTAMPING_RX_SOFTWARE
|
1029 SOF_TIMESTAMPING_SOFTWARE
|
1030 SOF_TIMESTAMPING_TX_HARDWARE
|
1031 SOF_TIMESTAMPING_RX_HARDWARE
|
1032 SOF_TIMESTAMPING_RAW_HARDWARE
;
1034 if (interface
->ptp_clock
)
1035 info
->phc_index
= ptp_clock_index(interface
->ptp_clock
);
1037 info
->phc_index
= -1;
1039 info
->tx_types
= (1 << HWTSTAMP_TX_OFF
) |
1040 (1 << HWTSTAMP_TX_ON
);
1042 info
->rx_filters
= (1 << HWTSTAMP_FILTER_NONE
) |
1043 (1 << HWTSTAMP_FILTER_ALL
);
1048 static const struct ethtool_ops fm10k_ethtool_ops
= {
1049 .get_strings
= fm10k_get_strings
,
1050 .get_sset_count
= fm10k_get_sset_count
,
1051 .get_ethtool_stats
= fm10k_get_ethtool_stats
,
1052 .get_drvinfo
= fm10k_get_drvinfo
,
1053 .get_link
= ethtool_op_get_link
,
1054 .get_pauseparam
= fm10k_get_pauseparam
,
1055 .set_pauseparam
= fm10k_set_pauseparam
,
1056 .get_msglevel
= fm10k_get_msglevel
,
1057 .set_msglevel
= fm10k_set_msglevel
,
1058 .get_ringparam
= fm10k_get_ringparam
,
1059 .set_ringparam
= fm10k_set_ringparam
,
1060 .get_coalesce
= fm10k_get_coalesce
,
1061 .set_coalesce
= fm10k_set_coalesce
,
1062 .get_rxnfc
= fm10k_get_rxnfc
,
1063 .set_rxnfc
= fm10k_set_rxnfc
,
1064 .get_regs
= fm10k_get_regs
,
1065 .get_regs_len
= fm10k_get_regs_len
,
1066 .self_test
= fm10k_self_test
,
1067 .get_rxfh_indir_size
= fm10k_get_reta_size
,
1068 .get_rxfh_key_size
= fm10k_get_rssrk_size
,
1069 .get_rxfh
= fm10k_get_rssh
,
1070 .set_rxfh
= fm10k_set_rssh
,
1071 .get_channels
= fm10k_get_channels
,
1072 .set_channels
= fm10k_set_channels
,
1073 .get_ts_info
= fm10k_get_ts_info
,
1076 void fm10k_set_ethtool_ops(struct net_device
*dev
)
1078 dev
->ethtool_ops
= &fm10k_ethtool_ops
;