1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (C) 2015 Cavium, Inc. |
4 | */ |
5 | |
6 | /* ETHTOOL Support for VNIC_VF Device*/ |
7 | |
8 | #include <linux/ethtool.h> |
9 | #include <linux/pci.h> |
10 | #include <linux/net_tstamp.h> |
11 | |
12 | #include "nic_reg.h" |
13 | #include "nic.h" |
14 | #include "nicvf_queues.h" |
15 | #include "q_struct.h" |
16 | #include "thunder_bgx.h" |
17 | #include "../common/cavium_ptp.h" |
18 | |
19 | #define DRV_NAME "nicvf" |
20 | |
21 | struct nicvf_stat { |
22 | char name[ETH_GSTRING_LEN]; |
23 | unsigned int index; |
24 | }; |
25 | |
26 | #define NICVF_HW_STAT(stat) { \ |
27 | .name = #stat, \ |
28 | .index = offsetof(struct nicvf_hw_stats, stat) / sizeof(u64), \ |
29 | } |
30 | |
31 | #define NICVF_DRV_STAT(stat) { \ |
32 | .name = #stat, \ |
33 | .index = offsetof(struct nicvf_drv_stats, stat) / sizeof(u64), \ |
34 | } |
35 | |
36 | static const struct nicvf_stat nicvf_hw_stats[] = { |
37 | NICVF_HW_STAT(rx_bytes), |
38 | NICVF_HW_STAT(rx_frames), |
39 | NICVF_HW_STAT(rx_ucast_frames), |
40 | NICVF_HW_STAT(rx_bcast_frames), |
41 | NICVF_HW_STAT(rx_mcast_frames), |
42 | NICVF_HW_STAT(rx_drops), |
43 | NICVF_HW_STAT(rx_drop_red), |
44 | NICVF_HW_STAT(rx_drop_red_bytes), |
45 | NICVF_HW_STAT(rx_drop_overrun), |
46 | NICVF_HW_STAT(rx_drop_overrun_bytes), |
47 | NICVF_HW_STAT(rx_drop_bcast), |
48 | NICVF_HW_STAT(rx_drop_mcast), |
49 | NICVF_HW_STAT(rx_drop_l3_bcast), |
50 | NICVF_HW_STAT(rx_drop_l3_mcast), |
51 | NICVF_HW_STAT(rx_fcs_errors), |
52 | NICVF_HW_STAT(rx_l2_errors), |
53 | NICVF_HW_STAT(tx_bytes), |
54 | NICVF_HW_STAT(tx_frames), |
55 | NICVF_HW_STAT(tx_ucast_frames), |
56 | NICVF_HW_STAT(tx_bcast_frames), |
57 | NICVF_HW_STAT(tx_mcast_frames), |
58 | NICVF_HW_STAT(tx_drops), |
59 | }; |
60 | |
61 | static const struct nicvf_stat nicvf_drv_stats[] = { |
62 | NICVF_DRV_STAT(rx_bgx_truncated_pkts), |
63 | NICVF_DRV_STAT(rx_jabber_errs), |
64 | NICVF_DRV_STAT(rx_fcs_errs), |
65 | NICVF_DRV_STAT(rx_bgx_errs), |
66 | NICVF_DRV_STAT(rx_prel2_errs), |
67 | NICVF_DRV_STAT(rx_l2_hdr_malformed), |
68 | NICVF_DRV_STAT(rx_oversize), |
69 | NICVF_DRV_STAT(rx_undersize), |
70 | NICVF_DRV_STAT(rx_l2_len_mismatch), |
71 | NICVF_DRV_STAT(rx_l2_pclp), |
72 | NICVF_DRV_STAT(rx_ip_ver_errs), |
73 | NICVF_DRV_STAT(rx_ip_csum_errs), |
74 | NICVF_DRV_STAT(rx_ip_hdr_malformed), |
75 | NICVF_DRV_STAT(rx_ip_payload_malformed), |
76 | NICVF_DRV_STAT(rx_ip_ttl_errs), |
77 | NICVF_DRV_STAT(rx_l3_pclp), |
78 | NICVF_DRV_STAT(rx_l4_malformed), |
79 | NICVF_DRV_STAT(rx_l4_csum_errs), |
80 | NICVF_DRV_STAT(rx_udp_len_errs), |
81 | NICVF_DRV_STAT(rx_l4_port_errs), |
82 | NICVF_DRV_STAT(rx_tcp_flag_errs), |
83 | NICVF_DRV_STAT(rx_tcp_offset_errs), |
84 | NICVF_DRV_STAT(rx_l4_pclp), |
85 | NICVF_DRV_STAT(rx_truncated_pkts), |
86 | |
87 | NICVF_DRV_STAT(tx_desc_fault), |
88 | NICVF_DRV_STAT(tx_hdr_cons_err), |
89 | NICVF_DRV_STAT(tx_subdesc_err), |
90 | NICVF_DRV_STAT(tx_max_size_exceeded), |
91 | NICVF_DRV_STAT(tx_imm_size_oflow), |
92 | NICVF_DRV_STAT(tx_data_seq_err), |
93 | NICVF_DRV_STAT(tx_mem_seq_err), |
94 | NICVF_DRV_STAT(tx_lock_viol), |
95 | NICVF_DRV_STAT(tx_data_fault), |
96 | NICVF_DRV_STAT(tx_tstmp_conflict), |
97 | NICVF_DRV_STAT(tx_tstmp_timeout), |
98 | NICVF_DRV_STAT(tx_mem_fault), |
99 | NICVF_DRV_STAT(tx_csum_overlap), |
100 | NICVF_DRV_STAT(tx_csum_overflow), |
101 | |
102 | NICVF_DRV_STAT(tx_tso), |
103 | NICVF_DRV_STAT(tx_timeout), |
104 | NICVF_DRV_STAT(txq_stop), |
105 | NICVF_DRV_STAT(txq_wake), |
106 | NICVF_DRV_STAT(rcv_buffer_alloc_failures), |
107 | NICVF_DRV_STAT(page_alloc), |
108 | }; |
109 | |
110 | static const struct nicvf_stat nicvf_queue_stats[] = { |
111 | { "bytes" , 0 }, |
112 | { "frames" , 1 }, |
113 | }; |
114 | |
115 | static const unsigned int nicvf_n_hw_stats = ARRAY_SIZE(nicvf_hw_stats); |
116 | static const unsigned int nicvf_n_drv_stats = ARRAY_SIZE(nicvf_drv_stats); |
117 | static const unsigned int nicvf_n_queue_stats = ARRAY_SIZE(nicvf_queue_stats); |
118 | |
119 | static int nicvf_get_link_ksettings(struct net_device *netdev, |
120 | struct ethtool_link_ksettings *cmd) |
121 | { |
122 | struct nicvf *nic = netdev_priv(dev: netdev); |
123 | u32 supported, advertising; |
124 | |
125 | supported = 0; |
126 | advertising = 0; |
127 | |
128 | if (!nic->link_up) { |
129 | cmd->base.duplex = DUPLEX_UNKNOWN; |
130 | cmd->base.speed = SPEED_UNKNOWN; |
131 | return 0; |
132 | } |
133 | |
134 | switch (nic->speed) { |
135 | case SPEED_1000: |
136 | cmd->base.port = PORT_MII | PORT_TP; |
137 | cmd->base.autoneg = AUTONEG_ENABLE; |
138 | supported |= SUPPORTED_MII | SUPPORTED_TP; |
139 | supported |= SUPPORTED_1000baseT_Full | |
140 | SUPPORTED_1000baseT_Half | |
141 | SUPPORTED_100baseT_Full | |
142 | SUPPORTED_100baseT_Half | |
143 | SUPPORTED_10baseT_Full | |
144 | SUPPORTED_10baseT_Half; |
145 | supported |= SUPPORTED_Autoneg; |
146 | advertising |= ADVERTISED_1000baseT_Full | |
147 | ADVERTISED_1000baseT_Half | |
148 | ADVERTISED_100baseT_Full | |
149 | ADVERTISED_100baseT_Half | |
150 | ADVERTISED_10baseT_Full | |
151 | ADVERTISED_10baseT_Half; |
152 | break; |
153 | case SPEED_10000: |
154 | if (nic->mac_type == BGX_MODE_RXAUI) { |
155 | cmd->base.port = PORT_TP; |
156 | supported |= SUPPORTED_TP; |
157 | } else { |
158 | cmd->base.port = PORT_FIBRE; |
159 | supported |= SUPPORTED_FIBRE; |
160 | } |
161 | cmd->base.autoneg = AUTONEG_DISABLE; |
162 | supported |= SUPPORTED_10000baseT_Full; |
163 | break; |
164 | case SPEED_40000: |
165 | cmd->base.port = PORT_FIBRE; |
166 | cmd->base.autoneg = AUTONEG_DISABLE; |
167 | supported |= SUPPORTED_FIBRE; |
168 | supported |= SUPPORTED_40000baseCR4_Full; |
169 | break; |
170 | } |
171 | cmd->base.duplex = nic->duplex; |
172 | cmd->base.speed = nic->speed; |
173 | |
174 | ethtool_convert_legacy_u32_to_link_mode(dst: cmd->link_modes.supported, |
175 | legacy_u32: supported); |
176 | ethtool_convert_legacy_u32_to_link_mode(dst: cmd->link_modes.advertising, |
177 | legacy_u32: advertising); |
178 | |
179 | return 0; |
180 | } |
181 | |
182 | static u32 nicvf_get_link(struct net_device *netdev) |
183 | { |
184 | struct nicvf *nic = netdev_priv(dev: netdev); |
185 | |
186 | return nic->link_up; |
187 | } |
188 | |
189 | static void nicvf_get_drvinfo(struct net_device *netdev, |
190 | struct ethtool_drvinfo *info) |
191 | { |
192 | struct nicvf *nic = netdev_priv(dev: netdev); |
193 | |
194 | strscpy(info->driver, DRV_NAME, sizeof(info->driver)); |
195 | strscpy(info->bus_info, pci_name(nic->pdev), sizeof(info->bus_info)); |
196 | } |
197 | |
198 | static u32 nicvf_get_msglevel(struct net_device *netdev) |
199 | { |
200 | struct nicvf *nic = netdev_priv(dev: netdev); |
201 | |
202 | return nic->msg_enable; |
203 | } |
204 | |
205 | static void nicvf_set_msglevel(struct net_device *netdev, u32 lvl) |
206 | { |
207 | struct nicvf *nic = netdev_priv(dev: netdev); |
208 | |
209 | nic->msg_enable = lvl; |
210 | } |
211 | |
212 | static void nicvf_get_qset_strings(struct nicvf *nic, u8 **data, int qset) |
213 | { |
214 | int stats, qidx; |
215 | int start_qidx = qset * MAX_RCV_QUEUES_PER_QS; |
216 | |
217 | for (qidx = 0; qidx < nic->qs->rq_cnt; qidx++) { |
218 | for (stats = 0; stats < nicvf_n_queue_stats; stats++) { |
219 | sprintf(buf: *data, fmt: "rxq%d: %s" , qidx + start_qidx, |
220 | nicvf_queue_stats[stats].name); |
221 | *data += ETH_GSTRING_LEN; |
222 | } |
223 | } |
224 | |
225 | for (qidx = 0; qidx < nic->qs->sq_cnt; qidx++) { |
226 | for (stats = 0; stats < nicvf_n_queue_stats; stats++) { |
227 | sprintf(buf: *data, fmt: "txq%d: %s" , qidx + start_qidx, |
228 | nicvf_queue_stats[stats].name); |
229 | *data += ETH_GSTRING_LEN; |
230 | } |
231 | } |
232 | } |
233 | |
234 | static void nicvf_get_strings(struct net_device *netdev, u32 sset, u8 *data) |
235 | { |
236 | struct nicvf *nic = netdev_priv(dev: netdev); |
237 | int stats; |
238 | int sqs; |
239 | |
240 | if (sset != ETH_SS_STATS) |
241 | return; |
242 | |
243 | for (stats = 0; stats < nicvf_n_hw_stats; stats++) { |
244 | memcpy(data, nicvf_hw_stats[stats].name, ETH_GSTRING_LEN); |
245 | data += ETH_GSTRING_LEN; |
246 | } |
247 | |
248 | for (stats = 0; stats < nicvf_n_drv_stats; stats++) { |
249 | memcpy(data, nicvf_drv_stats[stats].name, ETH_GSTRING_LEN); |
250 | data += ETH_GSTRING_LEN; |
251 | } |
252 | |
253 | nicvf_get_qset_strings(nic, data: &data, qset: 0); |
254 | |
255 | for (sqs = 0; sqs < nic->sqs_count; sqs++) { |
256 | if (!nic->snicvf[sqs]) |
257 | continue; |
258 | nicvf_get_qset_strings(nic: nic->snicvf[sqs], data: &data, qset: sqs + 1); |
259 | } |
260 | |
261 | for (stats = 0; stats < BGX_RX_STATS_COUNT; stats++) { |
262 | sprintf(buf: data, fmt: "bgx_rxstat%d: " , stats); |
263 | data += ETH_GSTRING_LEN; |
264 | } |
265 | |
266 | for (stats = 0; stats < BGX_TX_STATS_COUNT; stats++) { |
267 | sprintf(buf: data, fmt: "bgx_txstat%d: " , stats); |
268 | data += ETH_GSTRING_LEN; |
269 | } |
270 | } |
271 | |
272 | static int nicvf_get_sset_count(struct net_device *netdev, int sset) |
273 | { |
274 | struct nicvf *nic = netdev_priv(dev: netdev); |
275 | int qstats_count; |
276 | int sqs; |
277 | |
278 | if (sset != ETH_SS_STATS) |
279 | return -EINVAL; |
280 | |
281 | qstats_count = nicvf_n_queue_stats * |
282 | (nic->qs->rq_cnt + nic->qs->sq_cnt); |
283 | for (sqs = 0; sqs < nic->sqs_count; sqs++) { |
284 | struct nicvf *snic; |
285 | |
286 | snic = nic->snicvf[sqs]; |
287 | if (!snic) |
288 | continue; |
289 | qstats_count += nicvf_n_queue_stats * |
290 | (snic->qs->rq_cnt + snic->qs->sq_cnt); |
291 | } |
292 | |
293 | return nicvf_n_hw_stats + nicvf_n_drv_stats + |
294 | qstats_count + |
295 | BGX_RX_STATS_COUNT + BGX_TX_STATS_COUNT; |
296 | } |
297 | |
298 | static void nicvf_get_qset_stats(struct nicvf *nic, |
299 | struct ethtool_stats *stats, u64 **data) |
300 | { |
301 | int stat, qidx; |
302 | |
303 | if (!nic) |
304 | return; |
305 | |
306 | for (qidx = 0; qidx < nic->qs->rq_cnt; qidx++) { |
307 | nicvf_update_rq_stats(nic, rq_idx: qidx); |
308 | for (stat = 0; stat < nicvf_n_queue_stats; stat++) |
309 | *((*data)++) = ((u64 *)&nic->qs->rq[qidx].stats) |
310 | [nicvf_queue_stats[stat].index]; |
311 | } |
312 | |
313 | for (qidx = 0; qidx < nic->qs->sq_cnt; qidx++) { |
314 | nicvf_update_sq_stats(nic, sq_idx: qidx); |
315 | for (stat = 0; stat < nicvf_n_queue_stats; stat++) |
316 | *((*data)++) = ((u64 *)&nic->qs->sq[qidx].stats) |
317 | [nicvf_queue_stats[stat].index]; |
318 | } |
319 | } |
320 | |
321 | static void nicvf_get_ethtool_stats(struct net_device *netdev, |
322 | struct ethtool_stats *stats, u64 *data) |
323 | { |
324 | struct nicvf *nic = netdev_priv(dev: netdev); |
325 | int stat, tmp_stats; |
326 | int sqs, cpu; |
327 | |
328 | nicvf_update_stats(nic); |
329 | |
330 | /* Update LMAC stats */ |
331 | nicvf_update_lmac_stats(nic); |
332 | |
333 | for (stat = 0; stat < nicvf_n_hw_stats; stat++) |
334 | *(data++) = ((u64 *)&nic->hw_stats) |
335 | [nicvf_hw_stats[stat].index]; |
336 | for (stat = 0; stat < nicvf_n_drv_stats; stat++) { |
337 | tmp_stats = 0; |
338 | for_each_possible_cpu(cpu) |
339 | tmp_stats += ((u64 *)per_cpu_ptr(nic->drv_stats, cpu)) |
340 | [nicvf_drv_stats[stat].index]; |
341 | *(data++) = tmp_stats; |
342 | } |
343 | |
344 | nicvf_get_qset_stats(nic, stats, data: &data); |
345 | |
346 | for (sqs = 0; sqs < nic->sqs_count; sqs++) { |
347 | if (!nic->snicvf[sqs]) |
348 | continue; |
349 | nicvf_get_qset_stats(nic: nic->snicvf[sqs], stats, data: &data); |
350 | } |
351 | |
352 | for (stat = 0; stat < BGX_RX_STATS_COUNT; stat++) |
353 | *(data++) = nic->bgx_stats.rx_stats[stat]; |
354 | for (stat = 0; stat < BGX_TX_STATS_COUNT; stat++) |
355 | *(data++) = nic->bgx_stats.tx_stats[stat]; |
356 | } |
357 | |
358 | static int nicvf_get_regs_len(struct net_device *dev) |
359 | { |
360 | return sizeof(u64) * NIC_VF_REG_COUNT; |
361 | } |
362 | |
363 | static void nicvf_get_regs(struct net_device *dev, |
364 | struct ethtool_regs *regs, void *reg) |
365 | { |
366 | struct nicvf *nic = netdev_priv(dev); |
367 | u64 *p = (u64 *)reg; |
368 | u64 reg_offset; |
369 | int mbox, key, stat, q; |
370 | int i = 0; |
371 | |
372 | regs->version = 0; |
373 | memset(p, 0, NIC_VF_REG_COUNT); |
374 | |
375 | p[i++] = nicvf_reg_read(nic, NIC_VNIC_CFG); |
376 | /* Mailbox registers */ |
377 | for (mbox = 0; mbox < NIC_PF_VF_MAILBOX_SIZE; mbox++) |
378 | p[i++] = nicvf_reg_read(nic, |
379 | NIC_VF_PF_MAILBOX_0_1 | (mbox << 3)); |
380 | |
381 | p[i++] = nicvf_reg_read(nic, NIC_VF_INT); |
382 | p[i++] = nicvf_reg_read(nic, NIC_VF_INT_W1S); |
383 | p[i++] = nicvf_reg_read(nic, NIC_VF_ENA_W1C); |
384 | p[i++] = nicvf_reg_read(nic, NIC_VF_ENA_W1S); |
385 | p[i++] = nicvf_reg_read(nic, NIC_VNIC_RSS_CFG); |
386 | |
387 | for (key = 0; key < RSS_HASH_KEY_SIZE; key++) |
388 | p[i++] = nicvf_reg_read(nic, NIC_VNIC_RSS_KEY_0_4 | (key << 3)); |
389 | |
390 | /* Tx/Rx statistics */ |
391 | for (stat = 0; stat < TX_STATS_ENUM_LAST; stat++) |
392 | p[i++] = nicvf_reg_read(nic, |
393 | NIC_VNIC_TX_STAT_0_4 | (stat << 3)); |
394 | |
395 | for (i = 0; i < RX_STATS_ENUM_LAST; i++) |
396 | p[i++] = nicvf_reg_read(nic, |
397 | NIC_VNIC_RX_STAT_0_13 | (stat << 3)); |
398 | |
399 | p[i++] = nicvf_reg_read(nic, NIC_QSET_RQ_GEN_CFG); |
400 | |
401 | /* All completion queue's registers */ |
402 | for (q = 0; q < MAX_CMP_QUEUES_PER_QS; q++) { |
403 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_CFG, qidx: q); |
404 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_CFG2, qidx: q); |
405 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_THRESH, qidx: q); |
406 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_BASE, qidx: q); |
407 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_HEAD, qidx: q); |
408 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_TAIL, qidx: q); |
409 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_DOOR, qidx: q); |
410 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_STATUS, qidx: q); |
411 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_STATUS2, qidx: q); |
412 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_CQ_0_7_DEBUG, qidx: q); |
413 | } |
414 | |
415 | /* All receive queue's registers */ |
416 | for (q = 0; q < MAX_RCV_QUEUES_PER_QS; q++) { |
417 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RQ_0_7_CFG, qidx: q); |
418 | p[i++] = nicvf_queue_reg_read(nic, |
419 | NIC_QSET_RQ_0_7_STAT_0_1, qidx: q); |
420 | reg_offset = NIC_QSET_RQ_0_7_STAT_0_1 | (1 << 3); |
421 | p[i++] = nicvf_queue_reg_read(nic, offset: reg_offset, qidx: q); |
422 | } |
423 | |
424 | for (q = 0; q < MAX_SND_QUEUES_PER_QS; q++) { |
425 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_CFG, qidx: q); |
426 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_THRESH, qidx: q); |
427 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_BASE, qidx: q); |
428 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_HEAD, qidx: q); |
429 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_TAIL, qidx: q); |
430 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_DOOR, qidx: q); |
431 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_STATUS, qidx: q); |
432 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_DEBUG, qidx: q); |
433 | /* Padding, was NIC_QSET_SQ_0_7_CNM_CHG, which |
434 | * produces bus errors when read |
435 | */ |
436 | p[i++] = 0; |
437 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_SQ_0_7_STAT_0_1, qidx: q); |
438 | reg_offset = NIC_QSET_SQ_0_7_STAT_0_1 | (1 << 3); |
439 | p[i++] = nicvf_queue_reg_read(nic, offset: reg_offset, qidx: q); |
440 | } |
441 | |
442 | for (q = 0; q < MAX_RCV_BUF_DESC_RINGS_PER_QS; q++) { |
443 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_CFG, qidx: q); |
444 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_THRESH, qidx: q); |
445 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_BASE, qidx: q); |
446 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_HEAD, qidx: q); |
447 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_TAIL, qidx: q); |
448 | p[i++] = nicvf_queue_reg_read(nic, NIC_QSET_RBDR_0_1_DOOR, qidx: q); |
449 | p[i++] = nicvf_queue_reg_read(nic, |
450 | NIC_QSET_RBDR_0_1_STATUS0, qidx: q); |
451 | p[i++] = nicvf_queue_reg_read(nic, |
452 | NIC_QSET_RBDR_0_1_STATUS1, qidx: q); |
453 | reg_offset = NIC_QSET_RBDR_0_1_PREFETCH_STATUS; |
454 | p[i++] = nicvf_queue_reg_read(nic, offset: reg_offset, qidx: q); |
455 | } |
456 | } |
457 | |
458 | static int nicvf_get_coalesce(struct net_device *netdev, |
459 | struct ethtool_coalesce *cmd, |
460 | struct kernel_ethtool_coalesce *kernel_coal, |
461 | struct netlink_ext_ack *extack) |
462 | { |
463 | struct nicvf *nic = netdev_priv(dev: netdev); |
464 | |
465 | cmd->rx_coalesce_usecs = nic->cq_coalesce_usecs; |
466 | return 0; |
467 | } |
468 | |
469 | static void nicvf_get_ringparam(struct net_device *netdev, |
470 | struct ethtool_ringparam *ring, |
471 | struct kernel_ethtool_ringparam *kernel_ring, |
472 | struct netlink_ext_ack *extack) |
473 | { |
474 | struct nicvf *nic = netdev_priv(dev: netdev); |
475 | struct queue_set *qs = nic->qs; |
476 | |
477 | ring->rx_max_pending = MAX_CMP_QUEUE_LEN; |
478 | ring->rx_pending = qs->cq_len; |
479 | ring->tx_max_pending = MAX_SND_QUEUE_LEN; |
480 | ring->tx_pending = qs->sq_len; |
481 | } |
482 | |
483 | static int nicvf_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 nicvf *nic = netdev_priv(dev: netdev); |
489 | struct queue_set *qs = nic->qs; |
490 | u32 rx_count, tx_count; |
491 | |
492 | /* Due to HW errata this is not supported on T88 pass 1.x silicon */ |
493 | if (pass1_silicon(pdev: nic->pdev)) |
494 | return -EINVAL; |
495 | |
496 | if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending)) |
497 | return -EINVAL; |
498 | |
499 | tx_count = clamp_t(u32, ring->tx_pending, |
500 | MIN_SND_QUEUE_LEN, MAX_SND_QUEUE_LEN); |
501 | rx_count = clamp_t(u32, ring->rx_pending, |
502 | MIN_CMP_QUEUE_LEN, MAX_CMP_QUEUE_LEN); |
503 | |
504 | if ((tx_count == qs->sq_len) && (rx_count == qs->cq_len)) |
505 | return 0; |
506 | |
507 | /* Permitted lengths are 1K, 2K, 4K, 8K, 16K, 32K, 64K */ |
508 | qs->sq_len = rounddown_pow_of_two(tx_count); |
509 | qs->cq_len = rounddown_pow_of_two(rx_count); |
510 | |
511 | if (netif_running(dev: netdev)) { |
512 | nicvf_stop(netdev); |
513 | nicvf_open(netdev); |
514 | } |
515 | |
516 | return 0; |
517 | } |
518 | |
519 | static int (struct nicvf *nic, |
520 | struct ethtool_rxnfc *info) |
521 | { |
522 | info->data = 0; |
523 | |
524 | switch (info->flow_type) { |
525 | case TCP_V4_FLOW: |
526 | case TCP_V6_FLOW: |
527 | case UDP_V4_FLOW: |
528 | case UDP_V6_FLOW: |
529 | case SCTP_V4_FLOW: |
530 | case SCTP_V6_FLOW: |
531 | info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; |
532 | fallthrough; |
533 | case IPV4_FLOW: |
534 | case IPV6_FLOW: |
535 | info->data |= RXH_IP_SRC | RXH_IP_DST; |
536 | break; |
537 | default: |
538 | return -EINVAL; |
539 | } |
540 | |
541 | return 0; |
542 | } |
543 | |
544 | static int nicvf_get_rxnfc(struct net_device *dev, |
545 | struct ethtool_rxnfc *info, u32 *rules) |
546 | { |
547 | struct nicvf *nic = netdev_priv(dev); |
548 | int ret = -EOPNOTSUPP; |
549 | |
550 | switch (info->cmd) { |
551 | case ETHTOOL_GRXRINGS: |
552 | info->data = nic->rx_queues; |
553 | ret = 0; |
554 | break; |
555 | case ETHTOOL_GRXFH: |
556 | return nicvf_get_rss_hash_opts(nic, info); |
557 | default: |
558 | break; |
559 | } |
560 | return ret; |
561 | } |
562 | |
563 | static int (struct nicvf *nic, |
564 | struct ethtool_rxnfc *info) |
565 | { |
566 | struct nicvf_rss_info * = &nic->rss_info; |
567 | u64 = nicvf_reg_read(nic, NIC_VNIC_RSS_CFG); |
568 | |
569 | if (!rss->enable) |
570 | netdev_err(dev: nic->netdev, |
571 | format: "RSS is disabled, hash cannot be set\n" ); |
572 | |
573 | netdev_info(dev: nic->netdev, format: "Set RSS flow type = %d, data = %lld\n" , |
574 | info->flow_type, info->data); |
575 | |
576 | if (!(info->data & RXH_IP_SRC) || !(info->data & RXH_IP_DST)) |
577 | return -EINVAL; |
578 | |
579 | switch (info->flow_type) { |
580 | case TCP_V4_FLOW: |
581 | case TCP_V6_FLOW: |
582 | switch (info->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { |
583 | case 0: |
584 | rss_cfg &= ~(1ULL << RSS_HASH_TCP); |
585 | break; |
586 | case (RXH_L4_B_0_1 | RXH_L4_B_2_3): |
587 | rss_cfg |= (1ULL << RSS_HASH_TCP); |
588 | break; |
589 | default: |
590 | return -EINVAL; |
591 | } |
592 | break; |
593 | case UDP_V4_FLOW: |
594 | case UDP_V6_FLOW: |
595 | switch (info->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { |
596 | case 0: |
597 | rss_cfg &= ~(1ULL << RSS_HASH_UDP); |
598 | break; |
599 | case (RXH_L4_B_0_1 | RXH_L4_B_2_3): |
600 | rss_cfg |= (1ULL << RSS_HASH_UDP); |
601 | break; |
602 | default: |
603 | return -EINVAL; |
604 | } |
605 | break; |
606 | case SCTP_V4_FLOW: |
607 | case SCTP_V6_FLOW: |
608 | switch (info->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { |
609 | case 0: |
610 | rss_cfg &= ~(1ULL << RSS_HASH_L4ETC); |
611 | break; |
612 | case (RXH_L4_B_0_1 | RXH_L4_B_2_3): |
613 | rss_cfg |= (1ULL << RSS_HASH_L4ETC); |
614 | break; |
615 | default: |
616 | return -EINVAL; |
617 | } |
618 | break; |
619 | case IPV4_FLOW: |
620 | case IPV6_FLOW: |
621 | rss_cfg = RSS_HASH_IP; |
622 | break; |
623 | default: |
624 | return -EINVAL; |
625 | } |
626 | |
627 | nicvf_reg_write(nic, NIC_VNIC_RSS_CFG, val: rss_cfg); |
628 | return 0; |
629 | } |
630 | |
631 | static int nicvf_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info) |
632 | { |
633 | struct nicvf *nic = netdev_priv(dev); |
634 | |
635 | switch (info->cmd) { |
636 | case ETHTOOL_SRXFH: |
637 | return nicvf_set_rss_hash_opts(nic, info); |
638 | default: |
639 | break; |
640 | } |
641 | return -EOPNOTSUPP; |
642 | } |
643 | |
644 | static u32 nicvf_get_rxfh_key_size(struct net_device *netdev) |
645 | { |
646 | return RSS_HASH_KEY_SIZE * sizeof(u64); |
647 | } |
648 | |
649 | static u32 nicvf_get_rxfh_indir_size(struct net_device *dev) |
650 | { |
651 | struct nicvf *nic = netdev_priv(dev); |
652 | |
653 | return nic->rss_info.rss_size; |
654 | } |
655 | |
656 | static int nicvf_get_rxfh(struct net_device *dev, |
657 | struct ethtool_rxfh_param *rxfh) |
658 | { |
659 | struct nicvf *nic = netdev_priv(dev); |
660 | struct nicvf_rss_info * = &nic->rss_info; |
661 | int idx; |
662 | |
663 | if (rxfh->indir) { |
664 | for (idx = 0; idx < rss->rss_size; idx++) |
665 | rxfh->indir[idx] = rss->ind_tbl[idx]; |
666 | } |
667 | |
668 | if (rxfh->key) |
669 | memcpy(rxfh->key, rss->key, RSS_HASH_KEY_SIZE * sizeof(u64)); |
670 | |
671 | rxfh->hfunc = ETH_RSS_HASH_TOP; |
672 | |
673 | return 0; |
674 | } |
675 | |
676 | static int nicvf_set_rxfh(struct net_device *dev, |
677 | struct ethtool_rxfh_param *rxfh, |
678 | struct netlink_ext_ack *extack) |
679 | { |
680 | struct nicvf *nic = netdev_priv(dev); |
681 | struct nicvf_rss_info * = &nic->rss_info; |
682 | int idx; |
683 | |
684 | if (rxfh->hfunc != ETH_RSS_HASH_NO_CHANGE && |
685 | rxfh->hfunc != ETH_RSS_HASH_TOP) |
686 | return -EOPNOTSUPP; |
687 | |
688 | if (!rss->enable) { |
689 | netdev_err(dev: nic->netdev, |
690 | format: "RSS is disabled, cannot change settings\n" ); |
691 | return -EIO; |
692 | } |
693 | |
694 | if (rxfh->indir) { |
695 | for (idx = 0; idx < rss->rss_size; idx++) |
696 | rss->ind_tbl[idx] = rxfh->indir[idx]; |
697 | } |
698 | |
699 | if (rxfh->key) { |
700 | memcpy(rss->key, rxfh->key, RSS_HASH_KEY_SIZE * sizeof(u64)); |
701 | nicvf_set_rss_key(nic); |
702 | } |
703 | |
704 | nicvf_config_rss(nic); |
705 | return 0; |
706 | } |
707 | |
708 | /* Get no of queues device supports and current queue count */ |
709 | static void nicvf_get_channels(struct net_device *dev, |
710 | struct ethtool_channels *channel) |
711 | { |
712 | struct nicvf *nic = netdev_priv(dev); |
713 | |
714 | memset(channel, 0, sizeof(*channel)); |
715 | |
716 | channel->max_rx = nic->max_queues; |
717 | channel->max_tx = nic->max_queues; |
718 | |
719 | channel->rx_count = nic->rx_queues; |
720 | channel->tx_count = nic->tx_queues; |
721 | } |
722 | |
723 | /* Set no of Tx, Rx queues to be used */ |
724 | static int nicvf_set_channels(struct net_device *dev, |
725 | struct ethtool_channels *channel) |
726 | { |
727 | struct nicvf *nic = netdev_priv(dev); |
728 | int err = 0; |
729 | bool if_up = netif_running(dev); |
730 | u8 cqcount, txq_count; |
731 | |
732 | if (!channel->rx_count || !channel->tx_count) |
733 | return -EINVAL; |
734 | if (channel->rx_count > nic->max_queues) |
735 | return -EINVAL; |
736 | if (channel->tx_count > nic->max_queues) |
737 | return -EINVAL; |
738 | |
739 | if (channel->tx_count + channel->rx_count > nic->max_queues) { |
740 | if (nic->xdp_prog) { |
741 | netdev_err(dev: nic->netdev, |
742 | format: "XDP mode, RXQs + TXQs > Max %d\n" , |
743 | nic->max_queues); |
744 | return -EINVAL; |
745 | } |
746 | |
747 | xdp_clear_features_flag(dev: nic->netdev); |
748 | } else if (!pass1_silicon(pdev: nic->pdev)) { |
749 | xdp_set_features_flag(dev, val: NETDEV_XDP_ACT_BASIC); |
750 | } |
751 | |
752 | if (if_up) |
753 | nicvf_stop(netdev: dev); |
754 | |
755 | nic->rx_queues = channel->rx_count; |
756 | nic->tx_queues = channel->tx_count; |
757 | if (!nic->xdp_prog) |
758 | nic->xdp_tx_queues = 0; |
759 | else |
760 | nic->xdp_tx_queues = channel->rx_count; |
761 | |
762 | txq_count = nic->xdp_tx_queues + nic->tx_queues; |
763 | cqcount = max(nic->rx_queues, txq_count); |
764 | |
765 | if (cqcount > MAX_CMP_QUEUES_PER_QS) { |
766 | nic->sqs_count = roundup(cqcount, MAX_CMP_QUEUES_PER_QS); |
767 | nic->sqs_count = (nic->sqs_count / MAX_CMP_QUEUES_PER_QS) - 1; |
768 | } else { |
769 | nic->sqs_count = 0; |
770 | } |
771 | |
772 | nic->qs->rq_cnt = min_t(u8, nic->rx_queues, MAX_RCV_QUEUES_PER_QS); |
773 | nic->qs->sq_cnt = min_t(u8, txq_count, MAX_SND_QUEUES_PER_QS); |
774 | nic->qs->cq_cnt = max(nic->qs->rq_cnt, nic->qs->sq_cnt); |
775 | |
776 | err = nicvf_set_real_num_queues(netdev: dev, tx_queues: nic->tx_queues, rx_queues: nic->rx_queues); |
777 | if (err) |
778 | return err; |
779 | |
780 | if (if_up) |
781 | nicvf_open(netdev: dev); |
782 | |
783 | netdev_info(dev, format: "Setting num Tx rings to %d, Rx rings to %d success\n" , |
784 | nic->tx_queues, nic->rx_queues); |
785 | |
786 | return err; |
787 | } |
788 | |
789 | static void nicvf_get_pauseparam(struct net_device *dev, |
790 | struct ethtool_pauseparam *pause) |
791 | { |
792 | struct nicvf *nic = netdev_priv(dev); |
793 | union nic_mbx mbx = {}; |
794 | |
795 | /* Supported only for 10G/40G interfaces */ |
796 | if ((nic->mac_type == BGX_MODE_SGMII) || |
797 | (nic->mac_type == BGX_MODE_QSGMII) || |
798 | (nic->mac_type == BGX_MODE_RGMII)) |
799 | return; |
800 | |
801 | mbx.pfc.msg = NIC_MBOX_MSG_PFC; |
802 | mbx.pfc.get = 1; |
803 | if (!nicvf_send_msg_to_pf(vf: nic, mbx: &mbx)) { |
804 | pause->autoneg = nic->pfc.autoneg; |
805 | pause->rx_pause = nic->pfc.fc_rx; |
806 | pause->tx_pause = nic->pfc.fc_tx; |
807 | } |
808 | } |
809 | |
810 | static int nicvf_set_pauseparam(struct net_device *dev, |
811 | struct ethtool_pauseparam *pause) |
812 | { |
813 | struct nicvf *nic = netdev_priv(dev); |
814 | union nic_mbx mbx = {}; |
815 | |
816 | /* Supported only for 10G/40G interfaces */ |
817 | if ((nic->mac_type == BGX_MODE_SGMII) || |
818 | (nic->mac_type == BGX_MODE_QSGMII) || |
819 | (nic->mac_type == BGX_MODE_RGMII)) |
820 | return -EOPNOTSUPP; |
821 | |
822 | if (pause->autoneg) |
823 | return -EOPNOTSUPP; |
824 | |
825 | mbx.pfc.msg = NIC_MBOX_MSG_PFC; |
826 | mbx.pfc.get = 0; |
827 | mbx.pfc.fc_rx = pause->rx_pause; |
828 | mbx.pfc.fc_tx = pause->tx_pause; |
829 | if (nicvf_send_msg_to_pf(vf: nic, mbx: &mbx)) |
830 | return -EAGAIN; |
831 | |
832 | nic->pfc.fc_rx = pause->rx_pause; |
833 | nic->pfc.fc_tx = pause->tx_pause; |
834 | |
835 | return 0; |
836 | } |
837 | |
838 | static int nicvf_get_ts_info(struct net_device *netdev, |
839 | struct ethtool_ts_info *info) |
840 | { |
841 | struct nicvf *nic = netdev_priv(dev: netdev); |
842 | |
843 | if (!nic->ptp_clock) |
844 | return ethtool_op_get_ts_info(dev: netdev, eti: info); |
845 | |
846 | info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE | |
847 | SOF_TIMESTAMPING_RX_SOFTWARE | |
848 | SOF_TIMESTAMPING_SOFTWARE | |
849 | SOF_TIMESTAMPING_TX_HARDWARE | |
850 | SOF_TIMESTAMPING_RX_HARDWARE | |
851 | SOF_TIMESTAMPING_RAW_HARDWARE; |
852 | |
853 | info->phc_index = cavium_ptp_clock_index(clock: nic->ptp_clock); |
854 | |
855 | info->tx_types = (1 << HWTSTAMP_TX_OFF) | (1 << HWTSTAMP_TX_ON); |
856 | |
857 | info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) | |
858 | (1 << HWTSTAMP_FILTER_ALL); |
859 | |
860 | return 0; |
861 | } |
862 | |
863 | static const struct ethtool_ops nicvf_ethtool_ops = { |
864 | .get_link = nicvf_get_link, |
865 | .get_drvinfo = nicvf_get_drvinfo, |
866 | .get_msglevel = nicvf_get_msglevel, |
867 | .set_msglevel = nicvf_set_msglevel, |
868 | .get_strings = nicvf_get_strings, |
869 | .get_sset_count = nicvf_get_sset_count, |
870 | .get_ethtool_stats = nicvf_get_ethtool_stats, |
871 | .get_regs_len = nicvf_get_regs_len, |
872 | .get_regs = nicvf_get_regs, |
873 | .get_coalesce = nicvf_get_coalesce, |
874 | .get_ringparam = nicvf_get_ringparam, |
875 | .set_ringparam = nicvf_set_ringparam, |
876 | .get_rxnfc = nicvf_get_rxnfc, |
877 | .set_rxnfc = nicvf_set_rxnfc, |
878 | .get_rxfh_key_size = nicvf_get_rxfh_key_size, |
879 | .get_rxfh_indir_size = nicvf_get_rxfh_indir_size, |
880 | .get_rxfh = nicvf_get_rxfh, |
881 | .set_rxfh = nicvf_set_rxfh, |
882 | .get_channels = nicvf_get_channels, |
883 | .set_channels = nicvf_set_channels, |
884 | .get_pauseparam = nicvf_get_pauseparam, |
885 | .set_pauseparam = nicvf_set_pauseparam, |
886 | .get_ts_info = nicvf_get_ts_info, |
887 | .get_link_ksettings = nicvf_get_link_ksettings, |
888 | }; |
889 | |
890 | void nicvf_set_ethtool_ops(struct net_device *netdev) |
891 | { |
892 | netdev->ethtool_ops = &nicvf_ethtool_ops; |
893 | } |
894 | |