1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0-or-later
2 /*
3  * Copyright 2008 - 2016 Freescale Semiconductor Inc.
4  */
5 
6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
7 
8 #include <linux/string.h>
9 #include <linux/of_platform.h>
10 #include <linux/net_tstamp.h>
11 #include <linux/fsl/ptp_qoriq.h>
12 
13 #include "dpaa_eth.h"
14 #include "mac.h"
15 
16 static const char dpaa_stats_percpu[][ETH_GSTRING_LEN] = {
17 	"interrupts",
18 	"rx packets",
19 	"tx packets",
20 	"tx confirm",
21 	"tx S/G",
22 	"tx error",
23 	"rx error",
24 	"rx dropped",
25 	"tx dropped",
26 };
27 
28 static char dpaa_stats_global[][ETH_GSTRING_LEN] = {
29 	/* dpa rx errors */
30 	"rx dma error",
31 	"rx frame physical error",
32 	"rx frame size error",
33 	"rx header error",
34 
35 	/* demultiplexing errors */
36 	"qman cg_tdrop",
37 	"qman wred",
38 	"qman error cond",
39 	"qman early window",
40 	"qman late window",
41 	"qman fq tdrop",
42 	"qman fq retired",
43 	"qman orp disabled",
44 
45 	/* congestion related stats */
46 	"congestion time (ms)",
47 	"entered congestion",
48 	"congested (0/1)"
49 };
50 
51 #define DPAA_STATS_PERCPU_LEN ARRAY_SIZE(dpaa_stats_percpu)
52 #define DPAA_STATS_GLOBAL_LEN ARRAY_SIZE(dpaa_stats_global)
53 
54 static int dpaa_get_link_ksettings(struct net_device *net_dev,
55 				   struct ethtool_link_ksettings *cmd)
56 {
57 	if (!net_dev->phydev)
58 		return 0;
59 
60 	phy_ethtool_ksettings_get(net_dev->phydev, cmd);
61 
62 	return 0;
63 }
64 
65 static int dpaa_set_link_ksettings(struct net_device *net_dev,
66 				   const struct ethtool_link_ksettings *cmd)
67 {
68 	int err;
69 
70 	if (!net_dev->phydev)
71 		return -ENODEV;
72 
73 	err = phy_ethtool_ksettings_set(net_dev->phydev, cmd);
74 	if (err < 0)
75 		netdev_err(net_dev, "phy_ethtool_ksettings_set() = %d\n", err);
76 
77 	return err;
78 }
79 
80 static void dpaa_get_drvinfo(struct net_device *net_dev,
81 			     struct ethtool_drvinfo *drvinfo)
82 {
83 	strlcpy(drvinfo->driver, KBUILD_MODNAME,
84 		sizeof(drvinfo->driver));
85 	strlcpy(drvinfo->bus_info, dev_name(net_dev->dev.parent->parent),
86 		sizeof(drvinfo->bus_info));
87 }
88 
89 static u32 dpaa_get_msglevel(struct net_device *net_dev)
90 {
91 	return ((struct dpaa_priv *)netdev_priv(net_dev))->msg_enable;
92 }
93 
94 static void dpaa_set_msglevel(struct net_device *net_dev,
95 			      u32 msg_enable)
96 {
97 	((struct dpaa_priv *)netdev_priv(net_dev))->msg_enable = msg_enable;
98 }
99 
100 static int dpaa_nway_reset(struct net_device *net_dev)
101 {
102 	int err;
103 
104 	if (!net_dev->phydev)
105 		return -ENODEV;
106 
107 	err = 0;
108 	if (net_dev->phydev->autoneg) {
109 		err = phy_start_aneg(net_dev->phydev);
110 		if (err < 0)
111 			netdev_err(net_dev, "phy_start_aneg() = %d\n",
112 				   err);
113 	}
114 
115 	return err;
116 }
117 
118 static void dpaa_get_pauseparam(struct net_device *net_dev,
119 				struct ethtool_pauseparam *epause)
120 {
121 	struct mac_device *mac_dev;
122 	struct dpaa_priv *priv;
123 
124 	priv = netdev_priv(net_dev);
125 	mac_dev = priv->mac_dev;
126 
127 	if (!net_dev->phydev)
128 		return;
129 
130 	epause->autoneg = mac_dev->autoneg_pause;
131 	epause->rx_pause = mac_dev->rx_pause_active;
132 	epause->tx_pause = mac_dev->tx_pause_active;
133 }
134 
135 static int dpaa_set_pauseparam(struct net_device *net_dev,
136 			       struct ethtool_pauseparam *epause)
137 {
138 	struct mac_device *mac_dev;
139 	struct phy_device *phydev;
140 	bool rx_pause, tx_pause;
141 	struct dpaa_priv *priv;
142 	int err;
143 
144 	priv = netdev_priv(net_dev);
145 	mac_dev = priv->mac_dev;
146 
147 	phydev = net_dev->phydev;
148 	if (!phydev) {
149 		netdev_err(net_dev, "phy device not initialized\n");
150 		return -ENODEV;
151 	}
152 
153 	if (!phy_validate_pause(phydev, epause))
154 		return -EINVAL;
155 
156 	/* The MAC should know how to handle PAUSE frame autonegotiation before
157 	 * adjust_link is triggered by a forced renegotiation of sym/asym PAUSE
158 	 * settings.
159 	 */
160 	mac_dev->autoneg_pause = !!epause->autoneg;
161 	mac_dev->rx_pause_req = !!epause->rx_pause;
162 	mac_dev->tx_pause_req = !!epause->tx_pause;
163 
164 	/* Determine the sym/asym advertised PAUSE capabilities from the desired
165 	 * rx/tx pause settings.
166 	 */
167 
168 	phy_set_asym_pause(phydev, epause->rx_pause, epause->tx_pause);
169 
170 	fman_get_pause_cfg(mac_dev, &rx_pause, &tx_pause);
171 	err = fman_set_mac_active_pause(mac_dev, rx_pause, tx_pause);
172 	if (err < 0)
173 		netdev_err(net_dev, "set_mac_active_pause() = %d\n", err);
174 
175 	return err;
176 }
177 
178 static int dpaa_get_sset_count(struct net_device *net_dev, int type)
179 {
180 	unsigned int total_stats, num_stats;
181 
182 	num_stats   = num_online_cpus() + 1;
183 	total_stats = num_stats * (DPAA_STATS_PERCPU_LEN + 1) +
184 			DPAA_STATS_GLOBAL_LEN;
185 
186 	switch (type) {
187 	case ETH_SS_STATS:
188 		return total_stats;
189 	default:
190 		return -EOPNOTSUPP;
191 	}
192 }
193 
194 static void copy_stats(struct dpaa_percpu_priv *percpu_priv, int num_cpus,
195 		       int crr_cpu, u64 bp_count, u64 *data)
196 {
197 	int num_values = num_cpus + 1;
198 	int crr = 0;
199 
200 	/* update current CPU's stats and also add them to the total values */
201 	data[crr * num_values + crr_cpu] = percpu_priv->in_interrupt;
202 	data[crr++ * num_values + num_cpus] += percpu_priv->in_interrupt;
203 
204 	data[crr * num_values + crr_cpu] = percpu_priv->stats.rx_packets;
205 	data[crr++ * num_values + num_cpus] += percpu_priv->stats.rx_packets;
206 
207 	data[crr * num_values + crr_cpu] = percpu_priv->stats.tx_packets;
208 	data[crr++ * num_values + num_cpus] += percpu_priv->stats.tx_packets;
209 
210 	data[crr * num_values + crr_cpu] = percpu_priv->tx_confirm;
211 	data[crr++ * num_values + num_cpus] += percpu_priv->tx_confirm;
212 
213 	data[crr * num_values + crr_cpu] = percpu_priv->tx_frag_skbuffs;
214 	data[crr++ * num_values + num_cpus] += percpu_priv->tx_frag_skbuffs;
215 
216 	data[crr * num_values + crr_cpu] = percpu_priv->stats.tx_errors;
217 	data[crr++ * num_values + num_cpus] += percpu_priv->stats.tx_errors;
218 
219 	data[crr * num_values + crr_cpu] = percpu_priv->stats.rx_errors;
220 	data[crr++ * num_values + num_cpus] += percpu_priv->stats.rx_errors;
221 
222 	data[crr * num_values + crr_cpu] = percpu_priv->stats.rx_dropped;
223 	data[crr++ * num_values + num_cpus] += percpu_priv->stats.rx_dropped;
224 
225 	data[crr * num_values + crr_cpu] = percpu_priv->stats.tx_dropped;
226 	data[crr++ * num_values + num_cpus] += percpu_priv->stats.tx_dropped;
227 
228 	data[crr * num_values + crr_cpu] = bp_count;
229 	data[crr++ * num_values + num_cpus] += bp_count;
230 }
231 
232 static void dpaa_get_ethtool_stats(struct net_device *net_dev,
233 				   struct ethtool_stats *stats, u64 *data)
234 {
235 	struct dpaa_percpu_priv *percpu_priv;
236 	struct dpaa_rx_errors rx_errors;
237 	unsigned int num_cpus, offset;
238 	u64 bp_count, cg_time, cg_num;
239 	struct dpaa_ern_cnt ern_cnt;
240 	struct dpaa_bp *dpaa_bp;
241 	struct dpaa_priv *priv;
242 	int total_stats, i;
243 	bool cg_status;
244 
245 	total_stats = dpaa_get_sset_count(net_dev, ETH_SS_STATS);
246 	priv     = netdev_priv(net_dev);
247 	num_cpus = num_online_cpus();
248 
249 	memset(&bp_count, 0, sizeof(bp_count));
250 	memset(&rx_errors, 0, sizeof(struct dpaa_rx_errors));
251 	memset(&ern_cnt, 0, sizeof(struct dpaa_ern_cnt));
252 	memset(data, 0, total_stats * sizeof(u64));
253 
254 	for_each_online_cpu(i) {
255 		percpu_priv = per_cpu_ptr(priv->percpu_priv, i);
256 		dpaa_bp = priv->dpaa_bp;
257 		if (!dpaa_bp->percpu_count)
258 			continue;
259 		bp_count = *(per_cpu_ptr(dpaa_bp->percpu_count, i));
260 		rx_errors.dme += percpu_priv->rx_errors.dme;
261 		rx_errors.fpe += percpu_priv->rx_errors.fpe;
262 		rx_errors.fse += percpu_priv->rx_errors.fse;
263 		rx_errors.phe += percpu_priv->rx_errors.phe;
264 
265 		ern_cnt.cg_tdrop     += percpu_priv->ern_cnt.cg_tdrop;
266 		ern_cnt.wred         += percpu_priv->ern_cnt.wred;
267 		ern_cnt.err_cond     += percpu_priv->ern_cnt.err_cond;
268 		ern_cnt.early_window += percpu_priv->ern_cnt.early_window;
269 		ern_cnt.late_window  += percpu_priv->ern_cnt.late_window;
270 		ern_cnt.fq_tdrop     += percpu_priv->ern_cnt.fq_tdrop;
271 		ern_cnt.fq_retired   += percpu_priv->ern_cnt.fq_retired;
272 		ern_cnt.orp_zero     += percpu_priv->ern_cnt.orp_zero;
273 
274 		copy_stats(percpu_priv, num_cpus, i, bp_count, data);
275 	}
276 
277 	offset = (num_cpus + 1) * (DPAA_STATS_PERCPU_LEN + 1);
278 	memcpy(data + offset, &rx_errors, sizeof(struct dpaa_rx_errors));
279 
280 	offset += sizeof(struct dpaa_rx_errors) / sizeof(u64);
281 	memcpy(data + offset, &ern_cnt, sizeof(struct dpaa_ern_cnt));
282 
283 	/* gather congestion related counters */
284 	cg_num    = 0;
285 	cg_status = false;
286 	cg_time   = jiffies_to_msecs(priv->cgr_data.congested_jiffies);
287 	if (qman_query_cgr_congested(&priv->cgr_data.cgr, &cg_status) == 0) {
288 		cg_num    = priv->cgr_data.cgr_congested_count;
289 
290 		/* reset congestion stats (like QMan API does */
291 		priv->cgr_data.congested_jiffies   = 0;
292 		priv->cgr_data.cgr_congested_count = 0;
293 	}
294 
295 	offset += sizeof(struct dpaa_ern_cnt) / sizeof(u64);
296 	data[offset++] = cg_time;
297 	data[offset++] = cg_num;
298 	data[offset++] = cg_status;
299 }
300 
301 static void dpaa_get_strings(struct net_device *net_dev, u32 stringset,
302 			     u8 *data)
303 {
304 	unsigned int i, j, num_cpus, size;
305 	char string_cpu[ETH_GSTRING_LEN];
306 	u8 *strings;
307 
308 	memset(string_cpu, 0, sizeof(string_cpu));
309 	strings   = data;
310 	num_cpus  = num_online_cpus();
311 	size      = DPAA_STATS_GLOBAL_LEN * ETH_GSTRING_LEN;
312 
313 	for (i = 0; i < DPAA_STATS_PERCPU_LEN; i++) {
314 		for (j = 0; j < num_cpus; j++) {
315 			snprintf(string_cpu, ETH_GSTRING_LEN, "%s [CPU %d]",
316 				 dpaa_stats_percpu[i], j);
317 			memcpy(strings, string_cpu, ETH_GSTRING_LEN);
318 			strings += ETH_GSTRING_LEN;
319 		}
320 		snprintf(string_cpu, ETH_GSTRING_LEN, "%s [TOTAL]",
321 			 dpaa_stats_percpu[i]);
322 		memcpy(strings, string_cpu, ETH_GSTRING_LEN);
323 		strings += ETH_GSTRING_LEN;
324 	}
325 	for (j = 0; j < num_cpus; j++) {
326 		snprintf(string_cpu, ETH_GSTRING_LEN,
327 			 "bpool [CPU %d]", j);
328 		memcpy(strings, string_cpu, ETH_GSTRING_LEN);
329 		strings += ETH_GSTRING_LEN;
330 	}
331 	snprintf(string_cpu, ETH_GSTRING_LEN, "bpool [TOTAL]");
332 	memcpy(strings, string_cpu, ETH_GSTRING_LEN);
333 	strings += ETH_GSTRING_LEN;
334 
335 	memcpy(strings, dpaa_stats_global, size);
336 }
337 
338 static int dpaa_get_hash_opts(struct net_device *dev,
339 			      struct ethtool_rxnfc *cmd)
340 {
341 	struct dpaa_priv *priv = netdev_priv(dev);
342 
343 	cmd->data = 0;
344 
345 	switch (cmd->flow_type) {
346 	case TCP_V4_FLOW:
347 	case TCP_V6_FLOW:
348 	case UDP_V4_FLOW:
349 	case UDP_V6_FLOW:
350 		if (priv->keygen_in_use)
351 			cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
352 		fallthrough;
353 	case IPV4_FLOW:
354 	case IPV6_FLOW:
355 	case SCTP_V4_FLOW:
356 	case SCTP_V6_FLOW:
357 	case AH_ESP_V4_FLOW:
358 	case AH_ESP_V6_FLOW:
359 	case AH_V4_FLOW:
360 	case AH_V6_FLOW:
361 	case ESP_V4_FLOW:
362 	case ESP_V6_FLOW:
363 		if (priv->keygen_in_use)
364 			cmd->data |= RXH_IP_SRC | RXH_IP_DST;
365 		break;
366 	default:
367 		cmd->data = 0;
368 		break;
369 	}
370 
371 	return 0;
372 }
373 
374 static int dpaa_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
375 			  u32 *unused)
376 {
377 	int ret = -EOPNOTSUPP;
378 
379 	switch (cmd->cmd) {
380 	case ETHTOOL_GRXFH:
381 		ret = dpaa_get_hash_opts(dev, cmd);
382 		break;
383 	default:
384 		break;
385 	}
386 
387 	return ret;
388 }
389 
390 static void dpaa_set_hash(struct net_device *net_dev, bool enable)
391 {
392 	struct mac_device *mac_dev;
393 	struct fman_port *rxport;
394 	struct dpaa_priv *priv;
395 
396 	priv = netdev_priv(net_dev);
397 	mac_dev = priv->mac_dev;
398 	rxport = mac_dev->port[0];
399 
400 	fman_port_use_kg_hash(rxport, enable);
401 	priv->keygen_in_use = enable;
402 }
403 
404 static int dpaa_set_hash_opts(struct net_device *dev,
405 			      struct ethtool_rxnfc *nfc)
406 {
407 	int ret = -EINVAL;
408 
409 	/* we support hashing on IPv4/v6 src/dest IP and L4 src/dest port */
410 	if (nfc->data &
411 	    ~(RXH_IP_SRC | RXH_IP_DST | RXH_L4_B_0_1 | RXH_L4_B_2_3))
412 		return -EINVAL;
413 
414 	switch (nfc->flow_type) {
415 	case TCP_V4_FLOW:
416 	case TCP_V6_FLOW:
417 	case UDP_V4_FLOW:
418 	case UDP_V6_FLOW:
419 	case IPV4_FLOW:
420 	case IPV6_FLOW:
421 	case SCTP_V4_FLOW:
422 	case SCTP_V6_FLOW:
423 	case AH_ESP_V4_FLOW:
424 	case AH_ESP_V6_FLOW:
425 	case AH_V4_FLOW:
426 	case AH_V6_FLOW:
427 	case ESP_V4_FLOW:
428 	case ESP_V6_FLOW:
429 		dpaa_set_hash(dev, !!nfc->data);
430 		ret = 0;
431 		break;
432 	default:
433 		break;
434 	}
435 
436 	return ret;
437 }
438 
439 static int dpaa_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
440 {
441 	int ret = -EOPNOTSUPP;
442 
443 	switch (cmd->cmd) {
444 	case ETHTOOL_SRXFH:
445 		ret = dpaa_set_hash_opts(dev, cmd);
446 		break;
447 	default:
448 		break;
449 	}
450 
451 	return ret;
452 }
453 
454 static int dpaa_get_ts_info(struct net_device *net_dev,
455 			    struct ethtool_ts_info *info)
456 {
457 	struct device *dev = net_dev->dev.parent;
458 	struct device_node *mac_node = dev->of_node;
459 	struct device_node *fman_node = NULL, *ptp_node = NULL;
460 	struct platform_device *ptp_dev = NULL;
461 	struct ptp_qoriq *ptp = NULL;
462 
463 	info->phc_index = -1;
464 
465 	fman_node = of_get_parent(mac_node);
466 	if (fman_node) {
467 		ptp_node = of_parse_phandle(fman_node, "ptimer-handle", 0);
468 		of_node_put(fman_node);
469 	}
470 
471 	if (ptp_node) {
472 		ptp_dev = of_find_device_by_node(ptp_node);
473 		of_node_put(ptp_node);
474 	}
475 
476 	if (ptp_dev)
477 		ptp = platform_get_drvdata(ptp_dev);
478 
479 	if (ptp)
480 		info->phc_index = ptp->phc_index;
481 
482 	info->so_timestamping = SOF_TIMESTAMPING_TX_HARDWARE |
483 				SOF_TIMESTAMPING_RX_HARDWARE |
484 				SOF_TIMESTAMPING_RAW_HARDWARE;
485 	info->tx_types = (1 << HWTSTAMP_TX_OFF) |
486 			 (1 << HWTSTAMP_TX_ON);
487 	info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
488 			   (1 << HWTSTAMP_FILTER_ALL);
489 
490 	return 0;
491 }
492 
493 static int dpaa_get_coalesce(struct net_device *dev,
494 			     struct ethtool_coalesce *c,
495 			     struct kernel_ethtool_coalesce *kernel_coal,
496 			     struct netlink_ext_ack *extack)
497 {
498 	struct qman_portal *portal;
499 	u32 period;
500 	u8 thresh;
501 
502 	portal = qman_get_affine_portal(smp_processor_id());
503 	qman_portal_get_iperiod(portal, &period);
504 	qman_dqrr_get_ithresh(portal, &thresh);
505 
506 	c->rx_coalesce_usecs = period;
507 	c->rx_max_coalesced_frames = thresh;
508 
509 	return 0;
510 }
511 
512 static int dpaa_set_coalesce(struct net_device *dev,
513 			     struct ethtool_coalesce *c,
514 			     struct kernel_ethtool_coalesce *kernel_coal,
515 			     struct netlink_ext_ack *extack)
516 {
517 	const cpumask_t *cpus = qman_affine_cpus();
518 	bool needs_revert[NR_CPUS] = {false};
519 	struct qman_portal *portal;
520 	u32 period, prev_period;
521 	u8 thresh, prev_thresh;
522 	int cpu, res;
523 
524 	period = c->rx_coalesce_usecs;
525 	thresh = c->rx_max_coalesced_frames;
526 
527 	/* save previous values */
528 	portal = qman_get_affine_portal(smp_processor_id());
529 	qman_portal_get_iperiod(portal, &prev_period);
530 	qman_dqrr_get_ithresh(portal, &prev_thresh);
531 
532 	/* set new values */
533 	for_each_cpu_and(cpu, cpus, cpu_online_mask) {
534 		portal = qman_get_affine_portal(cpu);
535 		res = qman_portal_set_iperiod(portal, period);
536 		if (res)
537 			goto revert_values;
538 		res = qman_dqrr_set_ithresh(portal, thresh);
539 		if (res) {
540 			qman_portal_set_iperiod(portal, prev_period);
541 			goto revert_values;
542 		}
543 		needs_revert[cpu] = true;
544 	}
545 
546 	return 0;
547 
548 revert_values:
549 	/* restore previous values */
550 	for_each_cpu_and(cpu, cpus, cpu_online_mask) {
551 		if (!needs_revert[cpu])
552 			continue;
553 		portal = qman_get_affine_portal(cpu);
554 		/* previous values will not fail, ignore return value */
555 		qman_portal_set_iperiod(portal, prev_period);
556 		qman_dqrr_set_ithresh(portal, prev_thresh);
557 	}
558 
559 	return res;
560 }
561 
562 const struct ethtool_ops dpaa_ethtool_ops = {
563 	.supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS |
564 				     ETHTOOL_COALESCE_RX_MAX_FRAMES,
565 	.get_drvinfo = dpaa_get_drvinfo,
566 	.get_msglevel = dpaa_get_msglevel,
567 	.set_msglevel = dpaa_set_msglevel,
568 	.nway_reset = dpaa_nway_reset,
569 	.get_pauseparam = dpaa_get_pauseparam,
570 	.set_pauseparam = dpaa_set_pauseparam,
571 	.get_link = ethtool_op_get_link,
572 	.get_sset_count = dpaa_get_sset_count,
573 	.get_ethtool_stats = dpaa_get_ethtool_stats,
574 	.get_strings = dpaa_get_strings,
575 	.get_link_ksettings = dpaa_get_link_ksettings,
576 	.set_link_ksettings = dpaa_set_link_ksettings,
577 	.get_rxnfc = dpaa_get_rxnfc,
578 	.set_rxnfc = dpaa_set_rxnfc,
579 	.get_ts_info = dpaa_get_ts_info,
580 	.get_coalesce = dpaa_get_coalesce,
581 	.set_coalesce = dpaa_set_coalesce,
582 };
583