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