1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
2 /* Copyright 2017-2019 NXP */
3
4 #include <linux/net_tstamp.h>
5 #include <linux/module.h>
6 #include "enetc.h"
7
8 static const u32 enetc_si_regs[] = {
9 ENETC_SIMR, ENETC_SIPMAR0, ENETC_SIPMAR1, ENETC_SICBDRMR,
10 ENETC_SICBDRSR, ENETC_SICBDRBAR0, ENETC_SICBDRBAR1, ENETC_SICBDRPIR,
11 ENETC_SICBDRCIR, ENETC_SICBDRLENR, ENETC_SICAPR0, ENETC_SICAPR1,
12 ENETC_SIUEFDCR
13 };
14
15 static const u32 enetc_txbdr_regs[] = {
16 ENETC_TBMR, ENETC_TBSR, ENETC_TBBAR0, ENETC_TBBAR1,
17 ENETC_TBPIR, ENETC_TBCIR, ENETC_TBLENR, ENETC_TBIER, ENETC_TBICR0,
18 ENETC_TBICR1
19 };
20
21 static const u32 enetc_rxbdr_regs[] = {
22 ENETC_RBMR, ENETC_RBSR, ENETC_RBBSR, ENETC_RBCIR, ENETC_RBBAR0,
23 ENETC_RBBAR1, ENETC_RBPIR, ENETC_RBLENR, ENETC_RBIER, ENETC_RBICR0,
24 ENETC_RBICR1
25 };
26
27 static const u32 enetc_port_regs[] = {
28 ENETC_PMR, ENETC_PSR, ENETC_PSIPMR, ENETC_PSIPMAR0(0),
29 ENETC_PSIPMAR1(0), ENETC_PTXMBAR, ENETC_PCAPR0, ENETC_PCAPR1,
30 ENETC_PSICFGR0(0), ENETC_PRFSCAPR, ENETC_PTCMSDUR(0),
31 ENETC_PM0_CMD_CFG, ENETC_PM0_MAXFRM, ENETC_PM0_IF_MODE
32 };
33
enetc_get_reglen(struct net_device * ndev)34 static int enetc_get_reglen(struct net_device *ndev)
35 {
36 struct enetc_ndev_priv *priv = netdev_priv(ndev);
37 struct enetc_hw *hw = &priv->si->hw;
38 int len;
39
40 len = ARRAY_SIZE(enetc_si_regs);
41 len += ARRAY_SIZE(enetc_txbdr_regs) * priv->num_tx_rings;
42 len += ARRAY_SIZE(enetc_rxbdr_regs) * priv->num_rx_rings;
43
44 if (hw->port)
45 len += ARRAY_SIZE(enetc_port_regs);
46
47 len *= sizeof(u32) * 2; /* store 2 entries per reg: addr and value */
48
49 return len;
50 }
51
enetc_get_regs(struct net_device * ndev,struct ethtool_regs * regs,void * regbuf)52 static void enetc_get_regs(struct net_device *ndev, struct ethtool_regs *regs,
53 void *regbuf)
54 {
55 struct enetc_ndev_priv *priv = netdev_priv(ndev);
56 struct enetc_hw *hw = &priv->si->hw;
57 u32 *buf = (u32 *)regbuf;
58 int i, j;
59 u32 addr;
60
61 for (i = 0; i < ARRAY_SIZE(enetc_si_regs); i++) {
62 *buf++ = enetc_si_regs[i];
63 *buf++ = enetc_rd(hw, enetc_si_regs[i]);
64 }
65
66 for (i = 0; i < priv->num_tx_rings; i++) {
67 for (j = 0; j < ARRAY_SIZE(enetc_txbdr_regs); j++) {
68 addr = ENETC_BDR(TX, i, enetc_txbdr_regs[j]);
69
70 *buf++ = addr;
71 *buf++ = enetc_rd(hw, addr);
72 }
73 }
74
75 for (i = 0; i < priv->num_rx_rings; i++) {
76 for (j = 0; j < ARRAY_SIZE(enetc_rxbdr_regs); j++) {
77 addr = ENETC_BDR(RX, i, enetc_rxbdr_regs[j]);
78
79 *buf++ = addr;
80 *buf++ = enetc_rd(hw, addr);
81 }
82 }
83
84 if (!hw->port)
85 return;
86
87 for (i = 0; i < ARRAY_SIZE(enetc_port_regs); i++) {
88 addr = ENETC_PORT_BASE + enetc_port_regs[i];
89 *buf++ = addr;
90 *buf++ = enetc_rd(hw, addr);
91 }
92 }
93
94 static const struct {
95 int reg;
96 char name[ETH_GSTRING_LEN];
97 } enetc_si_counters[] = {
98 { ENETC_SIROCT, "SI rx octets" },
99 { ENETC_SIRFRM, "SI rx frames" },
100 { ENETC_SIRUCA, "SI rx u-cast frames" },
101 { ENETC_SIRMCA, "SI rx m-cast frames" },
102 { ENETC_SITOCT, "SI tx octets" },
103 { ENETC_SITFRM, "SI tx frames" },
104 { ENETC_SITUCA, "SI tx u-cast frames" },
105 { ENETC_SITMCA, "SI tx m-cast frames" },
106 { ENETC_RBDCR(0), "Rx ring 0 discarded frames" },
107 { ENETC_RBDCR(1), "Rx ring 1 discarded frames" },
108 { ENETC_RBDCR(2), "Rx ring 2 discarded frames" },
109 { ENETC_RBDCR(3), "Rx ring 3 discarded frames" },
110 { ENETC_RBDCR(4), "Rx ring 4 discarded frames" },
111 { ENETC_RBDCR(5), "Rx ring 5 discarded frames" },
112 { ENETC_RBDCR(6), "Rx ring 6 discarded frames" },
113 { ENETC_RBDCR(7), "Rx ring 7 discarded frames" },
114 { ENETC_RBDCR(8), "Rx ring 8 discarded frames" },
115 { ENETC_RBDCR(9), "Rx ring 9 discarded frames" },
116 { ENETC_RBDCR(10), "Rx ring 10 discarded frames" },
117 { ENETC_RBDCR(11), "Rx ring 11 discarded frames" },
118 { ENETC_RBDCR(12), "Rx ring 12 discarded frames" },
119 { ENETC_RBDCR(13), "Rx ring 13 discarded frames" },
120 { ENETC_RBDCR(14), "Rx ring 14 discarded frames" },
121 { ENETC_RBDCR(15), "Rx ring 15 discarded frames" },
122 };
123
124 static const struct {
125 int reg;
126 char name[ETH_GSTRING_LEN];
127 } enetc_port_counters[] = {
128 { ENETC_PM_REOCT(0), "MAC rx ethernet octets" },
129 { ENETC_PM_RALN(0), "MAC rx alignment errors" },
130 { ENETC_PM_RXPF(0), "MAC rx valid pause frames" },
131 { ENETC_PM_RFRM(0), "MAC rx valid frames" },
132 { ENETC_PM_RFCS(0), "MAC rx fcs errors" },
133 { ENETC_PM_RVLAN(0), "MAC rx VLAN frames" },
134 { ENETC_PM_RERR(0), "MAC rx frame errors" },
135 { ENETC_PM_RUCA(0), "MAC rx unicast frames" },
136 { ENETC_PM_RMCA(0), "MAC rx multicast frames" },
137 { ENETC_PM_RBCA(0), "MAC rx broadcast frames" },
138 { ENETC_PM_RDRP(0), "MAC rx dropped packets" },
139 { ENETC_PM_RPKT(0), "MAC rx packets" },
140 { ENETC_PM_RUND(0), "MAC rx undersized packets" },
141 { ENETC_PM_R64(0), "MAC rx 64 byte packets" },
142 { ENETC_PM_R127(0), "MAC rx 65-127 byte packets" },
143 { ENETC_PM_R255(0), "MAC rx 128-255 byte packets" },
144 { ENETC_PM_R511(0), "MAC rx 256-511 byte packets" },
145 { ENETC_PM_R1023(0), "MAC rx 512-1023 byte packets" },
146 { ENETC_PM_R1522(0), "MAC rx 1024-1522 byte packets" },
147 { ENETC_PM_R1523X(0), "MAC rx 1523 to max-octet packets" },
148 { ENETC_PM_ROVR(0), "MAC rx oversized packets" },
149 { ENETC_PM_RJBR(0), "MAC rx jabber packets" },
150 { ENETC_PM_RFRG(0), "MAC rx fragment packets" },
151 { ENETC_PM_RCNP(0), "MAC rx control packets" },
152 { ENETC_PM_RDRNTP(0), "MAC rx fifo drop" },
153 { ENETC_PM_TEOCT(0), "MAC tx ethernet octets" },
154 { ENETC_PM_TOCT(0), "MAC tx octets" },
155 { ENETC_PM_TCRSE(0), "MAC tx carrier sense errors" },
156 { ENETC_PM_TXPF(0), "MAC tx valid pause frames" },
157 { ENETC_PM_TFRM(0), "MAC tx frames" },
158 { ENETC_PM_TFCS(0), "MAC tx fcs errors" },
159 { ENETC_PM_TVLAN(0), "MAC tx VLAN frames" },
160 { ENETC_PM_TERR(0), "MAC tx frame errors" },
161 { ENETC_PM_TUCA(0), "MAC tx unicast frames" },
162 { ENETC_PM_TMCA(0), "MAC tx multicast frames" },
163 { ENETC_PM_TBCA(0), "MAC tx broadcast frames" },
164 { ENETC_PM_TPKT(0), "MAC tx packets" },
165 { ENETC_PM_TUND(0), "MAC tx undersized packets" },
166 { ENETC_PM_T64(0), "MAC tx 64 byte packets" },
167 { ENETC_PM_T127(0), "MAC tx 65-127 byte packets" },
168 { ENETC_PM_T255(0), "MAC tx 128-255 byte packets" },
169 { ENETC_PM_T511(0), "MAC tx 256-511 byte packets" },
170 { ENETC_PM_T1023(0), "MAC tx 512-1023 byte packets" },
171 { ENETC_PM_T1522(0), "MAC tx 1024-1522 byte packets" },
172 { ENETC_PM_T1523X(0), "MAC tx 1523 to max-octet packets" },
173 { ENETC_PM_TCNP(0), "MAC tx control packets" },
174 { ENETC_PM_TDFR(0), "MAC tx deferred packets" },
175 { ENETC_PM_TMCOL(0), "MAC tx multiple collisions" },
176 { ENETC_PM_TSCOL(0), "MAC tx single collisions" },
177 { ENETC_PM_TLCOL(0), "MAC tx late collisions" },
178 { ENETC_PM_TECOL(0), "MAC tx excessive collisions" },
179 { ENETC_UFDMF, "SI MAC nomatch u-cast discards" },
180 { ENETC_MFDMF, "SI MAC nomatch m-cast discards" },
181 { ENETC_PBFDSIR, "SI MAC nomatch b-cast discards" },
182 { ENETC_PUFDVFR, "SI VLAN nomatch u-cast discards" },
183 { ENETC_PMFDVFR, "SI VLAN nomatch m-cast discards" },
184 { ENETC_PBFDVFR, "SI VLAN nomatch b-cast discards" },
185 { ENETC_PFDMSAPR, "SI pruning discarded frames" },
186 { ENETC_PICDR(0), "ICM DR0 discarded frames" },
187 { ENETC_PICDR(1), "ICM DR1 discarded frames" },
188 { ENETC_PICDR(2), "ICM DR2 discarded frames" },
189 { ENETC_PICDR(3), "ICM DR3 discarded frames" },
190 };
191
192 static const char rx_ring_stats[][ETH_GSTRING_LEN] = {
193 "Rx ring %2d frames",
194 "Rx ring %2d alloc errors",
195 "Rx ring %2d XDP drops",
196 "Rx ring %2d recycles",
197 "Rx ring %2d recycle failures",
198 "Rx ring %2d redirects",
199 "Rx ring %2d redirect failures",
200 "Rx ring %2d redirect S/G",
201 };
202
203 static const char tx_ring_stats[][ETH_GSTRING_LEN] = {
204 "Tx ring %2d frames",
205 "Tx ring %2d XDP frames",
206 "Tx ring %2d XDP drops",
207 "Tx window drop %2d frames",
208 };
209
enetc_get_sset_count(struct net_device * ndev,int sset)210 static int enetc_get_sset_count(struct net_device *ndev, int sset)
211 {
212 struct enetc_ndev_priv *priv = netdev_priv(ndev);
213 int len;
214
215 if (sset != ETH_SS_STATS)
216 return -EOPNOTSUPP;
217
218 len = ARRAY_SIZE(enetc_si_counters) +
219 ARRAY_SIZE(tx_ring_stats) * priv->num_tx_rings +
220 ARRAY_SIZE(rx_ring_stats) * priv->num_rx_rings;
221
222 if (!enetc_si_is_pf(priv->si))
223 return len;
224
225 len += ARRAY_SIZE(enetc_port_counters);
226
227 return len;
228 }
229
enetc_get_strings(struct net_device * ndev,u32 stringset,u8 * data)230 static void enetc_get_strings(struct net_device *ndev, u32 stringset, u8 *data)
231 {
232 struct enetc_ndev_priv *priv = netdev_priv(ndev);
233 u8 *p = data;
234 int i, j;
235
236 switch (stringset) {
237 case ETH_SS_STATS:
238 for (i = 0; i < ARRAY_SIZE(enetc_si_counters); i++) {
239 strscpy(p, enetc_si_counters[i].name, ETH_GSTRING_LEN);
240 p += ETH_GSTRING_LEN;
241 }
242 for (i = 0; i < priv->num_tx_rings; i++) {
243 for (j = 0; j < ARRAY_SIZE(tx_ring_stats); j++) {
244 snprintf(p, ETH_GSTRING_LEN, tx_ring_stats[j],
245 i);
246 p += ETH_GSTRING_LEN;
247 }
248 }
249 for (i = 0; i < priv->num_rx_rings; i++) {
250 for (j = 0; j < ARRAY_SIZE(rx_ring_stats); j++) {
251 snprintf(p, ETH_GSTRING_LEN, rx_ring_stats[j],
252 i);
253 p += ETH_GSTRING_LEN;
254 }
255 }
256
257 if (!enetc_si_is_pf(priv->si))
258 break;
259
260 for (i = 0; i < ARRAY_SIZE(enetc_port_counters); i++) {
261 strscpy(p, enetc_port_counters[i].name,
262 ETH_GSTRING_LEN);
263 p += ETH_GSTRING_LEN;
264 }
265 break;
266 }
267 }
268
enetc_get_ethtool_stats(struct net_device * ndev,struct ethtool_stats * stats,u64 * data)269 static void enetc_get_ethtool_stats(struct net_device *ndev,
270 struct ethtool_stats *stats, u64 *data)
271 {
272 struct enetc_ndev_priv *priv = netdev_priv(ndev);
273 struct enetc_hw *hw = &priv->si->hw;
274 int i, o = 0;
275
276 for (i = 0; i < ARRAY_SIZE(enetc_si_counters); i++)
277 data[o++] = enetc_rd64(hw, enetc_si_counters[i].reg);
278
279 for (i = 0; i < priv->num_tx_rings; i++) {
280 data[o++] = priv->tx_ring[i]->stats.packets;
281 data[o++] = priv->tx_ring[i]->stats.xdp_tx;
282 data[o++] = priv->tx_ring[i]->stats.xdp_tx_drops;
283 data[o++] = priv->tx_ring[i]->stats.win_drop;
284 }
285
286 for (i = 0; i < priv->num_rx_rings; i++) {
287 data[o++] = priv->rx_ring[i]->stats.packets;
288 data[o++] = priv->rx_ring[i]->stats.rx_alloc_errs;
289 data[o++] = priv->rx_ring[i]->stats.xdp_drops;
290 data[o++] = priv->rx_ring[i]->stats.recycles;
291 data[o++] = priv->rx_ring[i]->stats.recycle_failures;
292 data[o++] = priv->rx_ring[i]->stats.xdp_redirect;
293 data[o++] = priv->rx_ring[i]->stats.xdp_redirect_failures;
294 data[o++] = priv->rx_ring[i]->stats.xdp_redirect_sg;
295 }
296
297 if (!enetc_si_is_pf(priv->si))
298 return;
299
300 for (i = 0; i < ARRAY_SIZE(enetc_port_counters); i++)
301 data[o++] = enetc_port_rd(hw, enetc_port_counters[i].reg);
302 }
303
enetc_get_pause_stats(struct net_device * ndev,struct ethtool_pause_stats * pause_stats)304 static void enetc_get_pause_stats(struct net_device *ndev,
305 struct ethtool_pause_stats *pause_stats)
306 {
307 struct enetc_ndev_priv *priv = netdev_priv(ndev);
308 struct enetc_hw *hw = &priv->si->hw;
309
310 pause_stats->tx_pause_frames = enetc_port_rd(hw, ENETC_PM_TXPF(0));
311 pause_stats->rx_pause_frames = enetc_port_rd(hw, ENETC_PM_RXPF(0));
312 }
313
enetc_mac_stats(struct enetc_hw * hw,int mac,struct ethtool_eth_mac_stats * s)314 static void enetc_mac_stats(struct enetc_hw *hw, int mac,
315 struct ethtool_eth_mac_stats *s)
316 {
317 s->FramesTransmittedOK = enetc_port_rd(hw, ENETC_PM_TFRM(mac));
318 s->SingleCollisionFrames = enetc_port_rd(hw, ENETC_PM_TSCOL(mac));
319 s->MultipleCollisionFrames = enetc_port_rd(hw, ENETC_PM_TMCOL(mac));
320 s->FramesReceivedOK = enetc_port_rd(hw, ENETC_PM_RFRM(mac));
321 s->FrameCheckSequenceErrors = enetc_port_rd(hw, ENETC_PM_RFCS(mac));
322 s->AlignmentErrors = enetc_port_rd(hw, ENETC_PM_RALN(mac));
323 s->OctetsTransmittedOK = enetc_port_rd(hw, ENETC_PM_TEOCT(mac));
324 s->FramesWithDeferredXmissions = enetc_port_rd(hw, ENETC_PM_TDFR(mac));
325 s->LateCollisions = enetc_port_rd(hw, ENETC_PM_TLCOL(mac));
326 s->FramesAbortedDueToXSColls = enetc_port_rd(hw, ENETC_PM_TECOL(mac));
327 s->FramesLostDueToIntMACXmitError = enetc_port_rd(hw, ENETC_PM_TERR(mac));
328 s->CarrierSenseErrors = enetc_port_rd(hw, ENETC_PM_TCRSE(mac));
329 s->OctetsReceivedOK = enetc_port_rd(hw, ENETC_PM_REOCT(mac));
330 s->FramesLostDueToIntMACRcvError = enetc_port_rd(hw, ENETC_PM_RDRNTP(mac));
331 s->MulticastFramesXmittedOK = enetc_port_rd(hw, ENETC_PM_TMCA(mac));
332 s->BroadcastFramesXmittedOK = enetc_port_rd(hw, ENETC_PM_TBCA(mac));
333 s->MulticastFramesReceivedOK = enetc_port_rd(hw, ENETC_PM_RMCA(mac));
334 s->BroadcastFramesReceivedOK = enetc_port_rd(hw, ENETC_PM_RBCA(mac));
335 }
336
enetc_ctrl_stats(struct enetc_hw * hw,int mac,struct ethtool_eth_ctrl_stats * s)337 static void enetc_ctrl_stats(struct enetc_hw *hw, int mac,
338 struct ethtool_eth_ctrl_stats *s)
339 {
340 s->MACControlFramesTransmitted = enetc_port_rd(hw, ENETC_PM_TCNP(mac));
341 s->MACControlFramesReceived = enetc_port_rd(hw, ENETC_PM_RCNP(mac));
342 }
343
344 static const struct ethtool_rmon_hist_range enetc_rmon_ranges[] = {
345 { 64, 64 },
346 { 65, 127 },
347 { 128, 255 },
348 { 256, 511 },
349 { 512, 1023 },
350 { 1024, 1522 },
351 { 1523, ENETC_MAC_MAXFRM_SIZE },
352 {},
353 };
354
enetc_rmon_stats(struct enetc_hw * hw,int mac,struct ethtool_rmon_stats * s,const struct ethtool_rmon_hist_range ** ranges)355 static void enetc_rmon_stats(struct enetc_hw *hw, int mac,
356 struct ethtool_rmon_stats *s,
357 const struct ethtool_rmon_hist_range **ranges)
358 {
359 s->undersize_pkts = enetc_port_rd(hw, ENETC_PM_RUND(mac));
360 s->oversize_pkts = enetc_port_rd(hw, ENETC_PM_ROVR(mac));
361 s->fragments = enetc_port_rd(hw, ENETC_PM_RFRG(mac));
362 s->jabbers = enetc_port_rd(hw, ENETC_PM_RJBR(mac));
363
364 s->hist[0] = enetc_port_rd(hw, ENETC_PM_R64(mac));
365 s->hist[1] = enetc_port_rd(hw, ENETC_PM_R127(mac));
366 s->hist[2] = enetc_port_rd(hw, ENETC_PM_R255(mac));
367 s->hist[3] = enetc_port_rd(hw, ENETC_PM_R511(mac));
368 s->hist[4] = enetc_port_rd(hw, ENETC_PM_R1023(mac));
369 s->hist[5] = enetc_port_rd(hw, ENETC_PM_R1522(mac));
370 s->hist[6] = enetc_port_rd(hw, ENETC_PM_R1523X(mac));
371
372 s->hist_tx[0] = enetc_port_rd(hw, ENETC_PM_T64(mac));
373 s->hist_tx[1] = enetc_port_rd(hw, ENETC_PM_T127(mac));
374 s->hist_tx[2] = enetc_port_rd(hw, ENETC_PM_T255(mac));
375 s->hist_tx[3] = enetc_port_rd(hw, ENETC_PM_T511(mac));
376 s->hist_tx[4] = enetc_port_rd(hw, ENETC_PM_T1023(mac));
377 s->hist_tx[5] = enetc_port_rd(hw, ENETC_PM_T1522(mac));
378 s->hist_tx[6] = enetc_port_rd(hw, ENETC_PM_T1523X(mac));
379
380 *ranges = enetc_rmon_ranges;
381 }
382
enetc_get_eth_mac_stats(struct net_device * ndev,struct ethtool_eth_mac_stats * mac_stats)383 static void enetc_get_eth_mac_stats(struct net_device *ndev,
384 struct ethtool_eth_mac_stats *mac_stats)
385 {
386 struct enetc_ndev_priv *priv = netdev_priv(ndev);
387 struct enetc_hw *hw = &priv->si->hw;
388
389 enetc_mac_stats(hw, 0, mac_stats);
390 }
391
enetc_get_eth_ctrl_stats(struct net_device * ndev,struct ethtool_eth_ctrl_stats * ctrl_stats)392 static void enetc_get_eth_ctrl_stats(struct net_device *ndev,
393 struct ethtool_eth_ctrl_stats *ctrl_stats)
394 {
395 struct enetc_ndev_priv *priv = netdev_priv(ndev);
396 struct enetc_hw *hw = &priv->si->hw;
397
398 enetc_ctrl_stats(hw, 0, ctrl_stats);
399 }
400
enetc_get_rmon_stats(struct net_device * ndev,struct ethtool_rmon_stats * rmon_stats,const struct ethtool_rmon_hist_range ** ranges)401 static void enetc_get_rmon_stats(struct net_device *ndev,
402 struct ethtool_rmon_stats *rmon_stats,
403 const struct ethtool_rmon_hist_range **ranges)
404 {
405 struct enetc_ndev_priv *priv = netdev_priv(ndev);
406 struct enetc_hw *hw = &priv->si->hw;
407
408 enetc_rmon_stats(hw, 0, rmon_stats, ranges);
409 }
410
411 #define ENETC_RSSHASH_L3 (RXH_L2DA | RXH_VLAN | RXH_L3_PROTO | RXH_IP_SRC | \
412 RXH_IP_DST)
413 #define ENETC_RSSHASH_L4 (ENETC_RSSHASH_L3 | RXH_L4_B_0_1 | RXH_L4_B_2_3)
enetc_get_rsshash(struct ethtool_rxnfc * rxnfc)414 static int enetc_get_rsshash(struct ethtool_rxnfc *rxnfc)
415 {
416 static const u32 rsshash[] = {
417 [TCP_V4_FLOW] = ENETC_RSSHASH_L4,
418 [UDP_V4_FLOW] = ENETC_RSSHASH_L4,
419 [SCTP_V4_FLOW] = ENETC_RSSHASH_L4,
420 [AH_ESP_V4_FLOW] = ENETC_RSSHASH_L3,
421 [IPV4_FLOW] = ENETC_RSSHASH_L3,
422 [TCP_V6_FLOW] = ENETC_RSSHASH_L4,
423 [UDP_V6_FLOW] = ENETC_RSSHASH_L4,
424 [SCTP_V6_FLOW] = ENETC_RSSHASH_L4,
425 [AH_ESP_V6_FLOW] = ENETC_RSSHASH_L3,
426 [IPV6_FLOW] = ENETC_RSSHASH_L3,
427 [ETHER_FLOW] = 0,
428 };
429
430 if (rxnfc->flow_type >= ARRAY_SIZE(rsshash))
431 return -EINVAL;
432
433 rxnfc->data = rsshash[rxnfc->flow_type];
434
435 return 0;
436 }
437
438 /* current HW spec does byte reversal on everything including MAC addresses */
ether_addr_copy_swap(u8 * dst,const u8 * src)439 static void ether_addr_copy_swap(u8 *dst, const u8 *src)
440 {
441 int i;
442
443 for (i = 0; i < ETH_ALEN; i++)
444 dst[i] = src[ETH_ALEN - i - 1];
445 }
446
enetc_set_cls_entry(struct enetc_si * si,struct ethtool_rx_flow_spec * fs,bool en)447 static int enetc_set_cls_entry(struct enetc_si *si,
448 struct ethtool_rx_flow_spec *fs, bool en)
449 {
450 struct ethtool_tcpip4_spec *l4ip4_h, *l4ip4_m;
451 struct ethtool_usrip4_spec *l3ip4_h, *l3ip4_m;
452 struct ethhdr *eth_h, *eth_m;
453 struct enetc_cmd_rfse rfse = { {0} };
454
455 if (!en)
456 goto done;
457
458 switch (fs->flow_type & 0xff) {
459 case TCP_V4_FLOW:
460 l4ip4_h = &fs->h_u.tcp_ip4_spec;
461 l4ip4_m = &fs->m_u.tcp_ip4_spec;
462 goto l4ip4;
463 case UDP_V4_FLOW:
464 l4ip4_h = &fs->h_u.udp_ip4_spec;
465 l4ip4_m = &fs->m_u.udp_ip4_spec;
466 goto l4ip4;
467 case SCTP_V4_FLOW:
468 l4ip4_h = &fs->h_u.sctp_ip4_spec;
469 l4ip4_m = &fs->m_u.sctp_ip4_spec;
470 l4ip4:
471 rfse.sip_h[0] = l4ip4_h->ip4src;
472 rfse.sip_m[0] = l4ip4_m->ip4src;
473 rfse.dip_h[0] = l4ip4_h->ip4dst;
474 rfse.dip_m[0] = l4ip4_m->ip4dst;
475 rfse.sport_h = ntohs(l4ip4_h->psrc);
476 rfse.sport_m = ntohs(l4ip4_m->psrc);
477 rfse.dport_h = ntohs(l4ip4_h->pdst);
478 rfse.dport_m = ntohs(l4ip4_m->pdst);
479 if (l4ip4_m->tos)
480 netdev_warn(si->ndev, "ToS field is not supported and was ignored\n");
481 rfse.ethtype_h = ETH_P_IP; /* IPv4 */
482 rfse.ethtype_m = 0xffff;
483 break;
484 case IP_USER_FLOW:
485 l3ip4_h = &fs->h_u.usr_ip4_spec;
486 l3ip4_m = &fs->m_u.usr_ip4_spec;
487
488 rfse.sip_h[0] = l3ip4_h->ip4src;
489 rfse.sip_m[0] = l3ip4_m->ip4src;
490 rfse.dip_h[0] = l3ip4_h->ip4dst;
491 rfse.dip_m[0] = l3ip4_m->ip4dst;
492 if (l3ip4_m->tos)
493 netdev_warn(si->ndev, "ToS field is not supported and was ignored\n");
494 rfse.ethtype_h = ETH_P_IP; /* IPv4 */
495 rfse.ethtype_m = 0xffff;
496 break;
497 case ETHER_FLOW:
498 eth_h = &fs->h_u.ether_spec;
499 eth_m = &fs->m_u.ether_spec;
500
501 ether_addr_copy_swap(rfse.smac_h, eth_h->h_source);
502 ether_addr_copy_swap(rfse.smac_m, eth_m->h_source);
503 ether_addr_copy_swap(rfse.dmac_h, eth_h->h_dest);
504 ether_addr_copy_swap(rfse.dmac_m, eth_m->h_dest);
505 rfse.ethtype_h = ntohs(eth_h->h_proto);
506 rfse.ethtype_m = ntohs(eth_m->h_proto);
507 break;
508 default:
509 return -EOPNOTSUPP;
510 }
511
512 rfse.mode |= ENETC_RFSE_EN;
513 if (fs->ring_cookie != RX_CLS_FLOW_DISC) {
514 rfse.mode |= ENETC_RFSE_MODE_BD;
515 rfse.result = fs->ring_cookie;
516 }
517 done:
518 return enetc_set_fs_entry(si, &rfse, fs->location);
519 }
520
enetc_get_rxnfc(struct net_device * ndev,struct ethtool_rxnfc * rxnfc,u32 * rule_locs)521 static int enetc_get_rxnfc(struct net_device *ndev, struct ethtool_rxnfc *rxnfc,
522 u32 *rule_locs)
523 {
524 struct enetc_ndev_priv *priv = netdev_priv(ndev);
525 int i, j;
526
527 switch (rxnfc->cmd) {
528 case ETHTOOL_GRXRINGS:
529 rxnfc->data = priv->num_rx_rings;
530 break;
531 case ETHTOOL_GRXFH:
532 /* get RSS hash config */
533 return enetc_get_rsshash(rxnfc);
534 case ETHTOOL_GRXCLSRLCNT:
535 /* total number of entries */
536 rxnfc->data = priv->si->num_fs_entries;
537 /* number of entries in use */
538 rxnfc->rule_cnt = 0;
539 for (i = 0; i < priv->si->num_fs_entries; i++)
540 if (priv->cls_rules[i].used)
541 rxnfc->rule_cnt++;
542 break;
543 case ETHTOOL_GRXCLSRULE:
544 if (rxnfc->fs.location >= priv->si->num_fs_entries)
545 return -EINVAL;
546
547 /* get entry x */
548 rxnfc->fs = priv->cls_rules[rxnfc->fs.location].fs;
549 break;
550 case ETHTOOL_GRXCLSRLALL:
551 /* total number of entries */
552 rxnfc->data = priv->si->num_fs_entries;
553 /* array of indexes of used entries */
554 j = 0;
555 for (i = 0; i < priv->si->num_fs_entries; i++) {
556 if (!priv->cls_rules[i].used)
557 continue;
558 if (j == rxnfc->rule_cnt)
559 return -EMSGSIZE;
560 rule_locs[j++] = i;
561 }
562 /* number of entries in use */
563 rxnfc->rule_cnt = j;
564 break;
565 default:
566 return -EOPNOTSUPP;
567 }
568
569 return 0;
570 }
571
enetc_set_rxnfc(struct net_device * ndev,struct ethtool_rxnfc * rxnfc)572 static int enetc_set_rxnfc(struct net_device *ndev, struct ethtool_rxnfc *rxnfc)
573 {
574 struct enetc_ndev_priv *priv = netdev_priv(ndev);
575 int err;
576
577 switch (rxnfc->cmd) {
578 case ETHTOOL_SRXCLSRLINS:
579 if (rxnfc->fs.location >= priv->si->num_fs_entries)
580 return -EINVAL;
581
582 if (rxnfc->fs.ring_cookie >= priv->num_rx_rings &&
583 rxnfc->fs.ring_cookie != RX_CLS_FLOW_DISC)
584 return -EINVAL;
585
586 err = enetc_set_cls_entry(priv->si, &rxnfc->fs, true);
587 if (err)
588 return err;
589 priv->cls_rules[rxnfc->fs.location].fs = rxnfc->fs;
590 priv->cls_rules[rxnfc->fs.location].used = 1;
591 break;
592 case ETHTOOL_SRXCLSRLDEL:
593 if (rxnfc->fs.location >= priv->si->num_fs_entries)
594 return -EINVAL;
595
596 err = enetc_set_cls_entry(priv->si, &rxnfc->fs, false);
597 if (err)
598 return err;
599 priv->cls_rules[rxnfc->fs.location].used = 0;
600 break;
601 default:
602 return -EOPNOTSUPP;
603 }
604
605 return 0;
606 }
607
enetc_get_rxfh_key_size(struct net_device * ndev)608 static u32 enetc_get_rxfh_key_size(struct net_device *ndev)
609 {
610 struct enetc_ndev_priv *priv = netdev_priv(ndev);
611
612 /* return the size of the RX flow hash key. PF only */
613 return (priv->si->hw.port) ? ENETC_RSSHASH_KEY_SIZE : 0;
614 }
615
enetc_get_rxfh_indir_size(struct net_device * ndev)616 static u32 enetc_get_rxfh_indir_size(struct net_device *ndev)
617 {
618 struct enetc_ndev_priv *priv = netdev_priv(ndev);
619
620 /* return the size of the RX flow hash indirection table */
621 return priv->si->num_rss;
622 }
623
enetc_get_rxfh(struct net_device * ndev,u32 * indir,u8 * key,u8 * hfunc)624 static int enetc_get_rxfh(struct net_device *ndev, u32 *indir, u8 *key,
625 u8 *hfunc)
626 {
627 struct enetc_ndev_priv *priv = netdev_priv(ndev);
628 struct enetc_hw *hw = &priv->si->hw;
629 int err = 0, i;
630
631 /* return hash function */
632 if (hfunc)
633 *hfunc = ETH_RSS_HASH_TOP;
634
635 /* return hash key */
636 if (key && hw->port)
637 for (i = 0; i < ENETC_RSSHASH_KEY_SIZE / 4; i++)
638 ((u32 *)key)[i] = enetc_port_rd(hw, ENETC_PRSSK(i));
639
640 /* return RSS table */
641 if (indir)
642 err = enetc_get_rss_table(priv->si, indir, priv->si->num_rss);
643
644 return err;
645 }
646
enetc_set_rss_key(struct enetc_hw * hw,const u8 * bytes)647 void enetc_set_rss_key(struct enetc_hw *hw, const u8 *bytes)
648 {
649 int i;
650
651 for (i = 0; i < ENETC_RSSHASH_KEY_SIZE / 4; i++)
652 enetc_port_wr(hw, ENETC_PRSSK(i), ((u32 *)bytes)[i]);
653 }
654
enetc_set_rxfh(struct net_device * ndev,const u32 * indir,const u8 * key,const u8 hfunc)655 static int enetc_set_rxfh(struct net_device *ndev, const u32 *indir,
656 const u8 *key, const u8 hfunc)
657 {
658 struct enetc_ndev_priv *priv = netdev_priv(ndev);
659 struct enetc_hw *hw = &priv->si->hw;
660 int err = 0;
661
662 /* set hash key, if PF */
663 if (key && hw->port)
664 enetc_set_rss_key(hw, key);
665
666 /* set RSS table */
667 if (indir)
668 err = enetc_set_rss_table(priv->si, indir, priv->si->num_rss);
669
670 return err;
671 }
672
enetc_get_ringparam(struct net_device * ndev,struct ethtool_ringparam * ring,struct kernel_ethtool_ringparam * kernel_ring,struct netlink_ext_ack * extack)673 static void enetc_get_ringparam(struct net_device *ndev,
674 struct ethtool_ringparam *ring,
675 struct kernel_ethtool_ringparam *kernel_ring,
676 struct netlink_ext_ack *extack)
677 {
678 struct enetc_ndev_priv *priv = netdev_priv(ndev);
679
680 ring->rx_pending = priv->rx_bd_count;
681 ring->tx_pending = priv->tx_bd_count;
682
683 /* do some h/w sanity checks for BDR length */
684 if (netif_running(ndev)) {
685 struct enetc_hw *hw = &priv->si->hw;
686 u32 val = enetc_rxbdr_rd(hw, 0, ENETC_RBLENR);
687
688 if (val != priv->rx_bd_count)
689 netif_err(priv, hw, ndev, "RxBDR[RBLENR] = %d!\n", val);
690
691 val = enetc_txbdr_rd(hw, 0, ENETC_TBLENR);
692
693 if (val != priv->tx_bd_count)
694 netif_err(priv, hw, ndev, "TxBDR[TBLENR] = %d!\n", val);
695 }
696 }
697
enetc_get_coalesce(struct net_device * ndev,struct ethtool_coalesce * ic,struct kernel_ethtool_coalesce * kernel_coal,struct netlink_ext_ack * extack)698 static int enetc_get_coalesce(struct net_device *ndev,
699 struct ethtool_coalesce *ic,
700 struct kernel_ethtool_coalesce *kernel_coal,
701 struct netlink_ext_ack *extack)
702 {
703 struct enetc_ndev_priv *priv = netdev_priv(ndev);
704 struct enetc_int_vector *v = priv->int_vector[0];
705
706 ic->tx_coalesce_usecs = enetc_cycles_to_usecs(priv->tx_ictt);
707 ic->rx_coalesce_usecs = enetc_cycles_to_usecs(v->rx_ictt);
708
709 ic->tx_max_coalesced_frames = ENETC_TXIC_PKTTHR;
710 ic->rx_max_coalesced_frames = ENETC_RXIC_PKTTHR;
711
712 ic->use_adaptive_rx_coalesce = priv->ic_mode & ENETC_IC_RX_ADAPTIVE;
713
714 return 0;
715 }
716
enetc_set_coalesce(struct net_device * ndev,struct ethtool_coalesce * ic,struct kernel_ethtool_coalesce * kernel_coal,struct netlink_ext_ack * extack)717 static int enetc_set_coalesce(struct net_device *ndev,
718 struct ethtool_coalesce *ic,
719 struct kernel_ethtool_coalesce *kernel_coal,
720 struct netlink_ext_ack *extack)
721 {
722 struct enetc_ndev_priv *priv = netdev_priv(ndev);
723 u32 rx_ictt, tx_ictt;
724 int i, ic_mode;
725 bool changed;
726
727 tx_ictt = enetc_usecs_to_cycles(ic->tx_coalesce_usecs);
728 rx_ictt = enetc_usecs_to_cycles(ic->rx_coalesce_usecs);
729
730 if (ic->rx_max_coalesced_frames != ENETC_RXIC_PKTTHR)
731 return -EOPNOTSUPP;
732
733 if (ic->tx_max_coalesced_frames != ENETC_TXIC_PKTTHR)
734 return -EOPNOTSUPP;
735
736 ic_mode = ENETC_IC_NONE;
737 if (ic->use_adaptive_rx_coalesce) {
738 ic_mode |= ENETC_IC_RX_ADAPTIVE;
739 rx_ictt = 0x1;
740 } else {
741 ic_mode |= rx_ictt ? ENETC_IC_RX_MANUAL : 0;
742 }
743
744 ic_mode |= tx_ictt ? ENETC_IC_TX_MANUAL : 0;
745
746 /* commit the settings */
747 changed = (ic_mode != priv->ic_mode) || (priv->tx_ictt != tx_ictt);
748
749 priv->ic_mode = ic_mode;
750 priv->tx_ictt = tx_ictt;
751
752 for (i = 0; i < priv->bdr_int_num; i++) {
753 struct enetc_int_vector *v = priv->int_vector[i];
754
755 v->rx_ictt = rx_ictt;
756 v->rx_dim_en = !!(ic_mode & ENETC_IC_RX_ADAPTIVE);
757 }
758
759 if (netif_running(ndev) && changed) {
760 /* reconfigure the operation mode of h/w interrupts,
761 * traffic needs to be paused in the process
762 */
763 enetc_stop(ndev);
764 enetc_start(ndev);
765 }
766
767 return 0;
768 }
769
enetc_get_ts_info(struct net_device * ndev,struct ethtool_ts_info * info)770 static int enetc_get_ts_info(struct net_device *ndev,
771 struct ethtool_ts_info *info)
772 {
773 int *phc_idx;
774
775 phc_idx = symbol_get(enetc_phc_index);
776 if (phc_idx) {
777 info->phc_index = *phc_idx;
778 symbol_put(enetc_phc_index);
779 } else {
780 info->phc_index = -1;
781 }
782
783 #ifdef CONFIG_FSL_ENETC_PTP_CLOCK
784 info->so_timestamping = SOF_TIMESTAMPING_TX_HARDWARE |
785 SOF_TIMESTAMPING_RX_HARDWARE |
786 SOF_TIMESTAMPING_RAW_HARDWARE |
787 SOF_TIMESTAMPING_TX_SOFTWARE |
788 SOF_TIMESTAMPING_RX_SOFTWARE |
789 SOF_TIMESTAMPING_SOFTWARE;
790
791 info->tx_types = (1 << HWTSTAMP_TX_OFF) |
792 (1 << HWTSTAMP_TX_ON) |
793 (1 << HWTSTAMP_TX_ONESTEP_SYNC);
794 info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
795 (1 << HWTSTAMP_FILTER_ALL);
796 #else
797 info->so_timestamping = SOF_TIMESTAMPING_RX_SOFTWARE |
798 SOF_TIMESTAMPING_TX_SOFTWARE |
799 SOF_TIMESTAMPING_SOFTWARE;
800 #endif
801 return 0;
802 }
803
enetc_get_wol(struct net_device * dev,struct ethtool_wolinfo * wol)804 static void enetc_get_wol(struct net_device *dev,
805 struct ethtool_wolinfo *wol)
806 {
807 wol->supported = 0;
808 wol->wolopts = 0;
809
810 if (dev->phydev)
811 phy_ethtool_get_wol(dev->phydev, wol);
812 }
813
enetc_set_wol(struct net_device * dev,struct ethtool_wolinfo * wol)814 static int enetc_set_wol(struct net_device *dev,
815 struct ethtool_wolinfo *wol)
816 {
817 int ret;
818
819 if (!dev->phydev)
820 return -EOPNOTSUPP;
821
822 ret = phy_ethtool_set_wol(dev->phydev, wol);
823 if (!ret)
824 device_set_wakeup_enable(&dev->dev, wol->wolopts);
825
826 return ret;
827 }
828
enetc_get_pauseparam(struct net_device * dev,struct ethtool_pauseparam * pause)829 static void enetc_get_pauseparam(struct net_device *dev,
830 struct ethtool_pauseparam *pause)
831 {
832 struct enetc_ndev_priv *priv = netdev_priv(dev);
833
834 phylink_ethtool_get_pauseparam(priv->phylink, pause);
835 }
836
enetc_set_pauseparam(struct net_device * dev,struct ethtool_pauseparam * pause)837 static int enetc_set_pauseparam(struct net_device *dev,
838 struct ethtool_pauseparam *pause)
839 {
840 struct enetc_ndev_priv *priv = netdev_priv(dev);
841
842 return phylink_ethtool_set_pauseparam(priv->phylink, pause);
843 }
844
enetc_get_link_ksettings(struct net_device * dev,struct ethtool_link_ksettings * cmd)845 static int enetc_get_link_ksettings(struct net_device *dev,
846 struct ethtool_link_ksettings *cmd)
847 {
848 struct enetc_ndev_priv *priv = netdev_priv(dev);
849
850 if (!priv->phylink)
851 return -EOPNOTSUPP;
852
853 return phylink_ethtool_ksettings_get(priv->phylink, cmd);
854 }
855
enetc_set_link_ksettings(struct net_device * dev,const struct ethtool_link_ksettings * cmd)856 static int enetc_set_link_ksettings(struct net_device *dev,
857 const struct ethtool_link_ksettings *cmd)
858 {
859 struct enetc_ndev_priv *priv = netdev_priv(dev);
860
861 if (!priv->phylink)
862 return -EOPNOTSUPP;
863
864 return phylink_ethtool_ksettings_set(priv->phylink, cmd);
865 }
866
867 static const struct ethtool_ops enetc_pf_ethtool_ops = {
868 .supported_coalesce_params = ETHTOOL_COALESCE_USECS |
869 ETHTOOL_COALESCE_MAX_FRAMES |
870 ETHTOOL_COALESCE_USE_ADAPTIVE_RX,
871 .get_regs_len = enetc_get_reglen,
872 .get_regs = enetc_get_regs,
873 .get_sset_count = enetc_get_sset_count,
874 .get_strings = enetc_get_strings,
875 .get_ethtool_stats = enetc_get_ethtool_stats,
876 .get_pause_stats = enetc_get_pause_stats,
877 .get_rmon_stats = enetc_get_rmon_stats,
878 .get_eth_ctrl_stats = enetc_get_eth_ctrl_stats,
879 .get_eth_mac_stats = enetc_get_eth_mac_stats,
880 .get_rxnfc = enetc_get_rxnfc,
881 .set_rxnfc = enetc_set_rxnfc,
882 .get_rxfh_key_size = enetc_get_rxfh_key_size,
883 .get_rxfh_indir_size = enetc_get_rxfh_indir_size,
884 .get_rxfh = enetc_get_rxfh,
885 .set_rxfh = enetc_set_rxfh,
886 .get_ringparam = enetc_get_ringparam,
887 .get_coalesce = enetc_get_coalesce,
888 .set_coalesce = enetc_set_coalesce,
889 .get_link_ksettings = enetc_get_link_ksettings,
890 .set_link_ksettings = enetc_set_link_ksettings,
891 .get_link = ethtool_op_get_link,
892 .get_ts_info = enetc_get_ts_info,
893 .get_wol = enetc_get_wol,
894 .set_wol = enetc_set_wol,
895 .get_pauseparam = enetc_get_pauseparam,
896 .set_pauseparam = enetc_set_pauseparam,
897 };
898
899 static const struct ethtool_ops enetc_vf_ethtool_ops = {
900 .supported_coalesce_params = ETHTOOL_COALESCE_USECS |
901 ETHTOOL_COALESCE_MAX_FRAMES |
902 ETHTOOL_COALESCE_USE_ADAPTIVE_RX,
903 .get_regs_len = enetc_get_reglen,
904 .get_regs = enetc_get_regs,
905 .get_sset_count = enetc_get_sset_count,
906 .get_strings = enetc_get_strings,
907 .get_ethtool_stats = enetc_get_ethtool_stats,
908 .get_rxnfc = enetc_get_rxnfc,
909 .set_rxnfc = enetc_set_rxnfc,
910 .get_rxfh_indir_size = enetc_get_rxfh_indir_size,
911 .get_rxfh = enetc_get_rxfh,
912 .set_rxfh = enetc_set_rxfh,
913 .get_ringparam = enetc_get_ringparam,
914 .get_coalesce = enetc_get_coalesce,
915 .set_coalesce = enetc_set_coalesce,
916 .get_link = ethtool_op_get_link,
917 .get_ts_info = enetc_get_ts_info,
918 };
919
enetc_set_ethtool_ops(struct net_device * ndev)920 void enetc_set_ethtool_ops(struct net_device *ndev)
921 {
922 struct enetc_ndev_priv *priv = netdev_priv(ndev);
923
924 if (enetc_si_is_pf(priv->si))
925 ndev->ethtool_ops = &enetc_pf_ethtool_ops;
926 else
927 ndev->ethtool_ops = &enetc_vf_ethtool_ops;
928 }
929
