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