1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
2 /* Copyright 2019 NXP */
3
4 #include <linux/acpi.h>
5 #include <linux/pcs-lynx.h>
6 #include <linux/phy/phy.h>
7 #include <linux/property.h>
8
9 #include "dpaa2-eth.h"
10 #include "dpaa2-mac.h"
11
12 #define phylink_to_dpaa2_mac(config) \
13 container_of((config), struct dpaa2_mac, phylink_config)
14
15 #define DPMAC_PROTOCOL_CHANGE_VER_MAJOR 4
16 #define DPMAC_PROTOCOL_CHANGE_VER_MINOR 8
17
18 #define DPAA2_MAC_FEATURE_PROTOCOL_CHANGE BIT(0)
19
dpaa2_mac_cmp_ver(struct dpaa2_mac * mac,u16 ver_major,u16 ver_minor)20 static int dpaa2_mac_cmp_ver(struct dpaa2_mac *mac,
21 u16 ver_major, u16 ver_minor)
22 {
23 if (mac->ver_major == ver_major)
24 return mac->ver_minor - ver_minor;
25 return mac->ver_major - ver_major;
26 }
27
dpaa2_mac_detect_features(struct dpaa2_mac * mac)28 static void dpaa2_mac_detect_features(struct dpaa2_mac *mac)
29 {
30 mac->features = 0;
31
32 if (dpaa2_mac_cmp_ver(mac, DPMAC_PROTOCOL_CHANGE_VER_MAJOR,
33 DPMAC_PROTOCOL_CHANGE_VER_MINOR) >= 0)
34 mac->features |= DPAA2_MAC_FEATURE_PROTOCOL_CHANGE;
35 }
36
phy_mode(enum dpmac_eth_if eth_if,phy_interface_t * if_mode)37 static int phy_mode(enum dpmac_eth_if eth_if, phy_interface_t *if_mode)
38 {
39 *if_mode = PHY_INTERFACE_MODE_NA;
40
41 switch (eth_if) {
42 case DPMAC_ETH_IF_RGMII:
43 *if_mode = PHY_INTERFACE_MODE_RGMII;
44 break;
45 case DPMAC_ETH_IF_USXGMII:
46 *if_mode = PHY_INTERFACE_MODE_USXGMII;
47 break;
48 case DPMAC_ETH_IF_QSGMII:
49 *if_mode = PHY_INTERFACE_MODE_QSGMII;
50 break;
51 case DPMAC_ETH_IF_SGMII:
52 *if_mode = PHY_INTERFACE_MODE_SGMII;
53 break;
54 case DPMAC_ETH_IF_XFI:
55 *if_mode = PHY_INTERFACE_MODE_10GBASER;
56 break;
57 default:
58 return -EINVAL;
59 }
60
61 return 0;
62 }
63
dpmac_eth_if_mode(phy_interface_t if_mode)64 static enum dpmac_eth_if dpmac_eth_if_mode(phy_interface_t if_mode)
65 {
66 switch (if_mode) {
67 case PHY_INTERFACE_MODE_RGMII:
68 case PHY_INTERFACE_MODE_RGMII_ID:
69 case PHY_INTERFACE_MODE_RGMII_RXID:
70 case PHY_INTERFACE_MODE_RGMII_TXID:
71 return DPMAC_ETH_IF_RGMII;
72 case PHY_INTERFACE_MODE_USXGMII:
73 return DPMAC_ETH_IF_USXGMII;
74 case PHY_INTERFACE_MODE_QSGMII:
75 return DPMAC_ETH_IF_QSGMII;
76 case PHY_INTERFACE_MODE_SGMII:
77 return DPMAC_ETH_IF_SGMII;
78 case PHY_INTERFACE_MODE_10GBASER:
79 return DPMAC_ETH_IF_XFI;
80 case PHY_INTERFACE_MODE_1000BASEX:
81 return DPMAC_ETH_IF_1000BASEX;
82 default:
83 return DPMAC_ETH_IF_MII;
84 }
85 }
86
dpaa2_mac_get_node(struct device * dev,u16 dpmac_id)87 static struct fwnode_handle *dpaa2_mac_get_node(struct device *dev,
88 u16 dpmac_id)
89 {
90 struct fwnode_handle *fwnode, *parent = NULL, *child = NULL;
91 struct device_node *dpmacs = NULL;
92 int err;
93 u32 id;
94
95 fwnode = dev_fwnode(dev->parent);
96 if (is_of_node(fwnode)) {
97 dpmacs = of_find_node_by_name(NULL, "dpmacs");
98 if (!dpmacs)
99 return NULL;
100 parent = of_fwnode_handle(dpmacs);
101 } else if (is_acpi_node(fwnode)) {
102 parent = fwnode;
103 } else {
104 /* The root dprc device didn't yet get to finalize it's probe,
105 * thus the fwnode field is not yet set. Defer probe if we are
106 * facing this situation.
107 */
108 return ERR_PTR(-EPROBE_DEFER);
109 }
110
111 fwnode_for_each_child_node(parent, child) {
112 err = -EINVAL;
113 if (is_acpi_device_node(child))
114 err = acpi_get_local_address(ACPI_HANDLE_FWNODE(child), &id);
115 else if (is_of_node(child))
116 err = of_property_read_u32(to_of_node(child), "reg", &id);
117 if (err)
118 continue;
119
120 if (id == dpmac_id) {
121 of_node_put(dpmacs);
122 return child;
123 }
124 }
125 of_node_put(dpmacs);
126 return NULL;
127 }
128
dpaa2_mac_get_if_mode(struct fwnode_handle * dpmac_node,struct dpmac_attr attr)129 static int dpaa2_mac_get_if_mode(struct fwnode_handle *dpmac_node,
130 struct dpmac_attr attr)
131 {
132 phy_interface_t if_mode;
133 int err;
134
135 err = fwnode_get_phy_mode(dpmac_node);
136 if (err > 0)
137 return err;
138
139 err = phy_mode(attr.eth_if, &if_mode);
140 if (!err)
141 return if_mode;
142
143 return err;
144 }
145
dpaa2_mac_select_pcs(struct phylink_config * config,phy_interface_t interface)146 static struct phylink_pcs *dpaa2_mac_select_pcs(struct phylink_config *config,
147 phy_interface_t interface)
148 {
149 struct dpaa2_mac *mac = phylink_to_dpaa2_mac(config);
150
151 return mac->pcs;
152 }
153
dpaa2_mac_config(struct phylink_config * config,unsigned int mode,const struct phylink_link_state * state)154 static void dpaa2_mac_config(struct phylink_config *config, unsigned int mode,
155 const struct phylink_link_state *state)
156 {
157 struct dpaa2_mac *mac = phylink_to_dpaa2_mac(config);
158 struct dpmac_link_state *dpmac_state = &mac->state;
159 int err;
160
161 if (state->an_enabled)
162 dpmac_state->options |= DPMAC_LINK_OPT_AUTONEG;
163 else
164 dpmac_state->options &= ~DPMAC_LINK_OPT_AUTONEG;
165
166 err = dpmac_set_link_state(mac->mc_io, 0,
167 mac->mc_dev->mc_handle, dpmac_state);
168 if (err)
169 netdev_err(mac->net_dev, "%s: dpmac_set_link_state() = %d\n",
170 __func__, err);
171
172 if (!mac->serdes_phy)
173 return;
174
175 /* This happens only if we support changing of protocol at runtime */
176 err = dpmac_set_protocol(mac->mc_io, 0, mac->mc_dev->mc_handle,
177 dpmac_eth_if_mode(state->interface));
178 if (err)
179 netdev_err(mac->net_dev, "dpmac_set_protocol() = %d\n", err);
180
181 err = phy_set_mode_ext(mac->serdes_phy, PHY_MODE_ETHERNET, state->interface);
182 if (err)
183 netdev_err(mac->net_dev, "phy_set_mode_ext() = %d\n", err);
184 }
185
dpaa2_mac_link_up(struct phylink_config * config,struct phy_device * phy,unsigned int mode,phy_interface_t interface,int speed,int duplex,bool tx_pause,bool rx_pause)186 static void dpaa2_mac_link_up(struct phylink_config *config,
187 struct phy_device *phy,
188 unsigned int mode, phy_interface_t interface,
189 int speed, int duplex,
190 bool tx_pause, bool rx_pause)
191 {
192 struct dpaa2_mac *mac = phylink_to_dpaa2_mac(config);
193 struct dpmac_link_state *dpmac_state = &mac->state;
194 int err;
195
196 dpmac_state->up = 1;
197
198 dpmac_state->rate = speed;
199
200 if (duplex == DUPLEX_HALF)
201 dpmac_state->options |= DPMAC_LINK_OPT_HALF_DUPLEX;
202 else if (duplex == DUPLEX_FULL)
203 dpmac_state->options &= ~DPMAC_LINK_OPT_HALF_DUPLEX;
204
205 if (rx_pause)
206 dpmac_state->options |= DPMAC_LINK_OPT_PAUSE;
207 else
208 dpmac_state->options &= ~DPMAC_LINK_OPT_PAUSE;
209
210 if (rx_pause ^ tx_pause)
211 dpmac_state->options |= DPMAC_LINK_OPT_ASYM_PAUSE;
212 else
213 dpmac_state->options &= ~DPMAC_LINK_OPT_ASYM_PAUSE;
214
215 err = dpmac_set_link_state(mac->mc_io, 0,
216 mac->mc_dev->mc_handle, dpmac_state);
217 if (err)
218 netdev_err(mac->net_dev, "%s: dpmac_set_link_state() = %d\n",
219 __func__, err);
220 }
221
dpaa2_mac_link_down(struct phylink_config * config,unsigned int mode,phy_interface_t interface)222 static void dpaa2_mac_link_down(struct phylink_config *config,
223 unsigned int mode,
224 phy_interface_t interface)
225 {
226 struct dpaa2_mac *mac = phylink_to_dpaa2_mac(config);
227 struct dpmac_link_state *dpmac_state = &mac->state;
228 int err;
229
230 dpmac_state->up = 0;
231 err = dpmac_set_link_state(mac->mc_io, 0,
232 mac->mc_dev->mc_handle, dpmac_state);
233 if (err)
234 netdev_err(mac->net_dev, "dpmac_set_link_state() = %d\n", err);
235 }
236
237 static const struct phylink_mac_ops dpaa2_mac_phylink_ops = {
238 .validate = phylink_generic_validate,
239 .mac_select_pcs = dpaa2_mac_select_pcs,
240 .mac_config = dpaa2_mac_config,
241 .mac_link_up = dpaa2_mac_link_up,
242 .mac_link_down = dpaa2_mac_link_down,
243 };
244
dpaa2_pcs_create(struct dpaa2_mac * mac,struct fwnode_handle * dpmac_node,int id)245 static int dpaa2_pcs_create(struct dpaa2_mac *mac,
246 struct fwnode_handle *dpmac_node,
247 int id)
248 {
249 struct mdio_device *mdiodev;
250 struct fwnode_handle *node;
251
252 node = fwnode_find_reference(dpmac_node, "pcs-handle", 0);
253 if (IS_ERR(node)) {
254 /* do not error out on old DTS files */
255 netdev_warn(mac->net_dev, "pcs-handle node not found\n");
256 return 0;
257 }
258
259 if (!fwnode_device_is_available(node)) {
260 netdev_err(mac->net_dev, "pcs-handle node not available\n");
261 fwnode_handle_put(node);
262 return -ENODEV;
263 }
264
265 mdiodev = fwnode_mdio_find_device(node);
266 fwnode_handle_put(node);
267 if (!mdiodev)
268 return -EPROBE_DEFER;
269
270 mac->pcs = lynx_pcs_create(mdiodev);
271 if (!mac->pcs) {
272 netdev_err(mac->net_dev, "lynx_pcs_create() failed\n");
273 put_device(&mdiodev->dev);
274 return -ENOMEM;
275 }
276
277 return 0;
278 }
279
dpaa2_pcs_destroy(struct dpaa2_mac * mac)280 static void dpaa2_pcs_destroy(struct dpaa2_mac *mac)
281 {
282 struct phylink_pcs *phylink_pcs = mac->pcs;
283
284 if (phylink_pcs) {
285 struct mdio_device *mdio = lynx_get_mdio_device(phylink_pcs);
286 struct device *dev = &mdio->dev;
287
288 lynx_pcs_destroy(phylink_pcs);
289 put_device(dev);
290 mac->pcs = NULL;
291 }
292 }
293
dpaa2_mac_set_supported_interfaces(struct dpaa2_mac * mac)294 static void dpaa2_mac_set_supported_interfaces(struct dpaa2_mac *mac)
295 {
296 int intf, err;
297
298 /* We support the current interface mode, and if we have a PCS
299 * similar interface modes that do not require the SerDes lane to be
300 * reconfigured.
301 */
302 __set_bit(mac->if_mode, mac->phylink_config.supported_interfaces);
303 if (mac->pcs) {
304 switch (mac->if_mode) {
305 case PHY_INTERFACE_MODE_1000BASEX:
306 case PHY_INTERFACE_MODE_SGMII:
307 __set_bit(PHY_INTERFACE_MODE_1000BASEX,
308 mac->phylink_config.supported_interfaces);
309 __set_bit(PHY_INTERFACE_MODE_SGMII,
310 mac->phylink_config.supported_interfaces);
311 break;
312
313 default:
314 break;
315 }
316 }
317
318 if (!mac->serdes_phy)
319 return;
320
321 /* In case we have access to the SerDes phy/lane, then ask the SerDes
322 * driver what interfaces are supported based on the current PLL
323 * configuration.
324 */
325 for (intf = 0; intf < PHY_INTERFACE_MODE_MAX; intf++) {
326 if (intf == PHY_INTERFACE_MODE_NA)
327 continue;
328
329 err = phy_validate(mac->serdes_phy, PHY_MODE_ETHERNET, intf, NULL);
330 if (err)
331 continue;
332
333 __set_bit(intf, mac->phylink_config.supported_interfaces);
334 }
335 }
336
dpaa2_mac_start(struct dpaa2_mac * mac)337 void dpaa2_mac_start(struct dpaa2_mac *mac)
338 {
339 if (mac->serdes_phy)
340 phy_power_on(mac->serdes_phy);
341 }
342
dpaa2_mac_stop(struct dpaa2_mac * mac)343 void dpaa2_mac_stop(struct dpaa2_mac *mac)
344 {
345 if (mac->serdes_phy)
346 phy_power_off(mac->serdes_phy);
347 }
348
dpaa2_mac_connect(struct dpaa2_mac * mac)349 int dpaa2_mac_connect(struct dpaa2_mac *mac)
350 {
351 struct net_device *net_dev = mac->net_dev;
352 struct fwnode_handle *dpmac_node;
353 struct phy *serdes_phy = NULL;
354 struct phylink *phylink;
355 int err;
356
357 mac->if_link_type = mac->attr.link_type;
358
359 dpmac_node = mac->fw_node;
360 if (!dpmac_node) {
361 netdev_err(net_dev, "No dpmac@%d node found.\n", mac->attr.id);
362 return -ENODEV;
363 }
364
365 err = dpaa2_mac_get_if_mode(dpmac_node, mac->attr);
366 if (err < 0)
367 return -EINVAL;
368 mac->if_mode = err;
369
370 if (mac->features & DPAA2_MAC_FEATURE_PROTOCOL_CHANGE &&
371 !phy_interface_mode_is_rgmii(mac->if_mode) &&
372 is_of_node(dpmac_node)) {
373 serdes_phy = of_phy_get(to_of_node(dpmac_node), NULL);
374
375 if (serdes_phy == ERR_PTR(-ENODEV))
376 serdes_phy = NULL;
377 else if (IS_ERR(serdes_phy))
378 return PTR_ERR(serdes_phy);
379 else
380 phy_init(serdes_phy);
381 }
382 mac->serdes_phy = serdes_phy;
383
384 /* The MAC does not have the capability to add RGMII delays so
385 * error out if the interface mode requests them and there is no PHY
386 * to act upon them
387 */
388 if (of_phy_is_fixed_link(to_of_node(dpmac_node)) &&
389 (mac->if_mode == PHY_INTERFACE_MODE_RGMII_ID ||
390 mac->if_mode == PHY_INTERFACE_MODE_RGMII_RXID ||
391 mac->if_mode == PHY_INTERFACE_MODE_RGMII_TXID)) {
392 netdev_err(net_dev, "RGMII delay not supported\n");
393 return -EINVAL;
394 }
395
396 if ((mac->attr.link_type == DPMAC_LINK_TYPE_PHY &&
397 mac->attr.eth_if != DPMAC_ETH_IF_RGMII) ||
398 mac->attr.link_type == DPMAC_LINK_TYPE_BACKPLANE) {
399 err = dpaa2_pcs_create(mac, dpmac_node, mac->attr.id);
400 if (err)
401 return err;
402 }
403
404 memset(&mac->phylink_config, 0, sizeof(mac->phylink_config));
405 mac->phylink_config.dev = &net_dev->dev;
406 mac->phylink_config.type = PHYLINK_NETDEV;
407
408 mac->phylink_config.mac_capabilities = MAC_SYM_PAUSE | MAC_ASYM_PAUSE |
409 MAC_10FD | MAC_100FD | MAC_1000FD | MAC_2500FD | MAC_5000FD |
410 MAC_10000FD;
411
412 dpaa2_mac_set_supported_interfaces(mac);
413
414 phylink = phylink_create(&mac->phylink_config,
415 dpmac_node, mac->if_mode,
416 &dpaa2_mac_phylink_ops);
417 if (IS_ERR(phylink)) {
418 err = PTR_ERR(phylink);
419 goto err_pcs_destroy;
420 }
421 mac->phylink = phylink;
422
423 err = phylink_fwnode_phy_connect(mac->phylink, dpmac_node, 0);
424 if (err) {
425 netdev_err(net_dev, "phylink_fwnode_phy_connect() = %d\n", err);
426 goto err_phylink_destroy;
427 }
428
429 return 0;
430
431 err_phylink_destroy:
432 phylink_destroy(mac->phylink);
433 err_pcs_destroy:
434 dpaa2_pcs_destroy(mac);
435
436 return err;
437 }
438
dpaa2_mac_disconnect(struct dpaa2_mac * mac)439 void dpaa2_mac_disconnect(struct dpaa2_mac *mac)
440 {
441 if (!mac->phylink)
442 return;
443
444 phylink_disconnect_phy(mac->phylink);
445 phylink_destroy(mac->phylink);
446 dpaa2_pcs_destroy(mac);
447 of_phy_put(mac->serdes_phy);
448 mac->serdes_phy = NULL;
449 }
450
dpaa2_mac_open(struct dpaa2_mac * mac)451 int dpaa2_mac_open(struct dpaa2_mac *mac)
452 {
453 struct fsl_mc_device *dpmac_dev = mac->mc_dev;
454 struct net_device *net_dev = mac->net_dev;
455 struct fwnode_handle *fw_node;
456 int err;
457
458 err = dpmac_open(mac->mc_io, 0, dpmac_dev->obj_desc.id,
459 &dpmac_dev->mc_handle);
460 if (err || !dpmac_dev->mc_handle) {
461 netdev_err(net_dev, "dpmac_open() = %d\n", err);
462 return -ENODEV;
463 }
464
465 err = dpmac_get_attributes(mac->mc_io, 0, dpmac_dev->mc_handle,
466 &mac->attr);
467 if (err) {
468 netdev_err(net_dev, "dpmac_get_attributes() = %d\n", err);
469 goto err_close_dpmac;
470 }
471
472 err = dpmac_get_api_version(mac->mc_io, 0, &mac->ver_major, &mac->ver_minor);
473 if (err) {
474 netdev_err(net_dev, "dpmac_get_api_version() = %d\n", err);
475 goto err_close_dpmac;
476 }
477
478 dpaa2_mac_detect_features(mac);
479
480 /* Find the device node representing the MAC device and link the device
481 * behind the associated netdev to it.
482 */
483 fw_node = dpaa2_mac_get_node(&mac->mc_dev->dev, mac->attr.id);
484 if (IS_ERR(fw_node)) {
485 err = PTR_ERR(fw_node);
486 goto err_close_dpmac;
487 }
488
489 mac->fw_node = fw_node;
490 net_dev->dev.of_node = to_of_node(mac->fw_node);
491
492 return 0;
493
494 err_close_dpmac:
495 dpmac_close(mac->mc_io, 0, dpmac_dev->mc_handle);
496 return err;
497 }
498
dpaa2_mac_close(struct dpaa2_mac * mac)499 void dpaa2_mac_close(struct dpaa2_mac *mac)
500 {
501 struct fsl_mc_device *dpmac_dev = mac->mc_dev;
502
503 dpmac_close(mac->mc_io, 0, dpmac_dev->mc_handle);
504 if (mac->fw_node)
505 fwnode_handle_put(mac->fw_node);
506 }
507
508 static char dpaa2_mac_ethtool_stats[][ETH_GSTRING_LEN] = {
509 [DPMAC_CNT_ING_ALL_FRAME] = "[mac] rx all frames",
510 [DPMAC_CNT_ING_GOOD_FRAME] = "[mac] rx frames ok",
511 [DPMAC_CNT_ING_ERR_FRAME] = "[mac] rx frame errors",
512 [DPMAC_CNT_ING_FRAME_DISCARD] = "[mac] rx frame discards",
513 [DPMAC_CNT_ING_UCAST_FRAME] = "[mac] rx u-cast",
514 [DPMAC_CNT_ING_BCAST_FRAME] = "[mac] rx b-cast",
515 [DPMAC_CNT_ING_MCAST_FRAME] = "[mac] rx m-cast",
516 [DPMAC_CNT_ING_FRAME_64] = "[mac] rx 64 bytes",
517 [DPMAC_CNT_ING_FRAME_127] = "[mac] rx 65-127 bytes",
518 [DPMAC_CNT_ING_FRAME_255] = "[mac] rx 128-255 bytes",
519 [DPMAC_CNT_ING_FRAME_511] = "[mac] rx 256-511 bytes",
520 [DPMAC_CNT_ING_FRAME_1023] = "[mac] rx 512-1023 bytes",
521 [DPMAC_CNT_ING_FRAME_1518] = "[mac] rx 1024-1518 bytes",
522 [DPMAC_CNT_ING_FRAME_1519_MAX] = "[mac] rx 1519-max bytes",
523 [DPMAC_CNT_ING_FRAG] = "[mac] rx frags",
524 [DPMAC_CNT_ING_JABBER] = "[mac] rx jabber",
525 [DPMAC_CNT_ING_ALIGN_ERR] = "[mac] rx align errors",
526 [DPMAC_CNT_ING_OVERSIZED] = "[mac] rx oversized",
527 [DPMAC_CNT_ING_VALID_PAUSE_FRAME] = "[mac] rx pause",
528 [DPMAC_CNT_ING_BYTE] = "[mac] rx bytes",
529 [DPMAC_CNT_EGR_GOOD_FRAME] = "[mac] tx frames ok",
530 [DPMAC_CNT_EGR_UCAST_FRAME] = "[mac] tx u-cast",
531 [DPMAC_CNT_EGR_MCAST_FRAME] = "[mac] tx m-cast",
532 [DPMAC_CNT_EGR_BCAST_FRAME] = "[mac] tx b-cast",
533 [DPMAC_CNT_EGR_ERR_FRAME] = "[mac] tx frame errors",
534 [DPMAC_CNT_EGR_UNDERSIZED] = "[mac] tx undersized",
535 [DPMAC_CNT_EGR_VALID_PAUSE_FRAME] = "[mac] tx b-pause",
536 [DPMAC_CNT_EGR_BYTE] = "[mac] tx bytes",
537 };
538
539 #define DPAA2_MAC_NUM_STATS ARRAY_SIZE(dpaa2_mac_ethtool_stats)
540
dpaa2_mac_get_sset_count(void)541 int dpaa2_mac_get_sset_count(void)
542 {
543 return DPAA2_MAC_NUM_STATS;
544 }
545
dpaa2_mac_get_strings(u8 * data)546 void dpaa2_mac_get_strings(u8 *data)
547 {
548 u8 *p = data;
549 int i;
550
551 for (i = 0; i < DPAA2_MAC_NUM_STATS; i++) {
552 strscpy(p, dpaa2_mac_ethtool_stats[i], ETH_GSTRING_LEN);
553 p += ETH_GSTRING_LEN;
554 }
555 }
556
dpaa2_mac_get_ethtool_stats(struct dpaa2_mac * mac,u64 * data)557 void dpaa2_mac_get_ethtool_stats(struct dpaa2_mac *mac, u64 *data)
558 {
559 struct fsl_mc_device *dpmac_dev = mac->mc_dev;
560 int i, err;
561 u64 value;
562
563 for (i = 0; i < DPAA2_MAC_NUM_STATS; i++) {
564 err = dpmac_get_counter(mac->mc_io, 0, dpmac_dev->mc_handle,
565 i, &value);
566 if (err) {
567 netdev_err_once(mac->net_dev,
568 "dpmac_get_counter error %d\n", err);
569 *(data + i) = U64_MAX;
570 continue;
571 }
572 *(data + i) = value;
573 }
574 }
575