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