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