1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause) 2 /* Copyright 2019, 2024-2026 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 DPMAC_STATS_BUNDLE_VER_MAJOR 4 19 #define DPMAC_STATS_BUNDLE_VER_MINOR 10 20 21 #define DPMAC_STANDARD_STATS_VER_MAJOR 4 22 #define DPMAC_STANDARD_STATS_VER_MINOR 11 23 24 #define DPAA2_MAC_FEATURE_PROTOCOL_CHANGE BIT(0) 25 #define DPAA2_MAC_FEATURE_STATS_BUNDLE BIT(1) 26 #define DPAA2_MAC_FEATURE_STANDARD_STATS BIT(2) 27 28 struct dpmac_counter { 29 enum dpmac_counter_id id; 30 size_t offset; 31 const char *name; 32 }; 33 34 #define DPMAC_COUNTER(counter_id, struct_name, struct_offset) \ 35 { \ 36 .id = counter_id, \ 37 .offset = offsetof(struct_name, struct_offset), \ 38 } 39 40 #define DPMAC_UNSTRUCTURED_COUNTER(counter_id, counter_name) \ 41 { \ 42 .id = counter_id, \ 43 .name = counter_name, \ 44 } 45 46 #define DPMAC_RMON_COUNTER(counter_id, struct_offset) \ 47 DPMAC_COUNTER(counter_id, struct ethtool_rmon_stats, struct_offset) 48 49 #define DPMAC_PAUSE_COUNTER(counter_id, struct_offset) \ 50 DPMAC_COUNTER(counter_id, struct ethtool_pause_stats, struct_offset) 51 52 #define DPMAC_CTRL_COUNTER(counter_id, struct_offset) \ 53 DPMAC_COUNTER(counter_id, struct ethtool_eth_ctrl_stats, struct_offset) 54 55 #define DPMAC_MAC_COUNTER(counter_id, struct_offset) \ 56 DPMAC_COUNTER(counter_id, struct ethtool_eth_mac_stats, struct_offset) 57 58 static const struct dpmac_counter dpaa2_mac_ethtool_stats[] = { 59 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_ALL_FRAME, "[mac] rx all frames"), 60 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_GOOD_FRAME, "[mac] rx frames ok"), 61 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_ERR_FRAME, "[mac] rx frame errors"), 62 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_FRAME_DISCARD, "[mac] rx frame discards"), 63 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_UCAST_FRAME, "[mac] rx u-cast"), 64 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_BCAST_FRAME, "[mac] rx b-cast"), 65 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_MCAST_FRAME, "[mac] rx m-cast"), 66 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_FRAME_64, "[mac] rx 64 bytes"), 67 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_FRAME_127, "[mac] rx 65-127 bytes"), 68 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_FRAME_255, "[mac] rx 128-255 bytes"), 69 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_FRAME_511, "[mac] rx 256-511 bytes"), 70 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_FRAME_1023, "[mac] rx 512-1023 bytes"), 71 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_FRAME_1518, "[mac] rx 1024-1518 bytes"), 72 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_FRAME_1519_MAX, "[mac] rx 1519-max bytes"), 73 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_FRAG, "[mac] rx frags"), 74 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_JABBER, "[mac] rx jabber"), 75 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_ALIGN_ERR, "[mac] rx align errors"), 76 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_OVERSIZED, "[mac] rx oversized"), 77 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_VALID_PAUSE_FRAME, "[mac] rx pause"), 78 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_ING_BYTE, "[mac] rx bytes"), 79 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_EGR_GOOD_FRAME, "[mac] tx frames ok"), 80 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_EGR_UCAST_FRAME, "[mac] tx u-cast"), 81 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_EGR_MCAST_FRAME, "[mac] tx m-cast"), 82 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_EGR_BCAST_FRAME, "[mac] tx b-cast"), 83 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_EGR_ERR_FRAME, "[mac] tx frame errors"), 84 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_EGR_UNDERSIZED, "[mac] tx undersized"), 85 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_EGR_VALID_PAUSE_FRAME, "[mac] tx b-pause"), 86 DPMAC_UNSTRUCTURED_COUNTER(DPMAC_CNT_EGR_BYTE, "[mac] tx bytes"), 87 }; 88 89 #define DPAA2_MAC_NUM_ETHTOOL_STATS ARRAY_SIZE(dpaa2_mac_ethtool_stats) 90 91 static const struct dpmac_counter dpaa2_mac_rmon_stats[] = { 92 DPMAC_RMON_COUNTER(DPMAC_CNT_ING_FRAME_64, hist[0]), 93 DPMAC_RMON_COUNTER(DPMAC_CNT_ING_FRAME_127, hist[1]), 94 DPMAC_RMON_COUNTER(DPMAC_CNT_ING_FRAME_255, hist[2]), 95 DPMAC_RMON_COUNTER(DPMAC_CNT_ING_FRAME_511, hist[3]), 96 DPMAC_RMON_COUNTER(DPMAC_CNT_ING_FRAME_1023, hist[4]), 97 DPMAC_RMON_COUNTER(DPMAC_CNT_ING_FRAME_1518, hist[5]), 98 DPMAC_RMON_COUNTER(DPMAC_CNT_ING_FRAME_1519_MAX, hist[6]), 99 DPMAC_RMON_COUNTER(DPMAC_CNT_EGR_FRAME_64, hist_tx[0]), 100 DPMAC_RMON_COUNTER(DPMAC_CNT_EGR_FRAME_127, hist_tx[1]), 101 DPMAC_RMON_COUNTER(DPMAC_CNT_EGR_FRAME_255, hist_tx[2]), 102 DPMAC_RMON_COUNTER(DPMAC_CNT_EGR_FRAME_511, hist_tx[3]), 103 DPMAC_RMON_COUNTER(DPMAC_CNT_EGR_FRAME_1023, hist_tx[4]), 104 DPMAC_RMON_COUNTER(DPMAC_CNT_EGR_FRAME_1518, hist_tx[5]), 105 DPMAC_RMON_COUNTER(DPMAC_CNT_EGR_FRAME_1519_MAX, hist_tx[6]), 106 DPMAC_RMON_COUNTER(DPMAC_CNT_ING_UNDERSIZED, undersize_pkts), 107 DPMAC_RMON_COUNTER(DPMAC_CNT_ING_OVERSIZED, oversize_pkts), 108 DPMAC_RMON_COUNTER(DPMAC_CNT_ING_FRAG, fragments), 109 DPMAC_RMON_COUNTER(DPMAC_CNT_ING_JABBER, jabbers), 110 }; 111 112 #define DPAA2_MAC_NUM_RMON_STATS ARRAY_SIZE(dpaa2_mac_rmon_stats) 113 114 static const struct dpmac_counter dpaa2_mac_pause_stats[] = { 115 DPMAC_PAUSE_COUNTER(DPMAC_CNT_ING_VALID_PAUSE_FRAME, rx_pause_frames), 116 DPMAC_PAUSE_COUNTER(DPMAC_CNT_EGR_VALID_PAUSE_FRAME, tx_pause_frames), 117 }; 118 119 #define DPAA2_MAC_NUM_PAUSE_STATS ARRAY_SIZE(dpaa2_mac_pause_stats) 120 121 static const struct dpmac_counter dpaa2_mac_eth_ctrl_stats[] = { 122 DPMAC_CTRL_COUNTER(DPMAC_CNT_ING_CONTROL_FRAME, MACControlFramesReceived), 123 DPMAC_CTRL_COUNTER(DPMAC_CNT_EGR_CONTROL_FRAME, MACControlFramesTransmitted), 124 }; 125 126 #define DPAA2_MAC_NUM_ETH_CTRL_STATS ARRAY_SIZE(dpaa2_mac_eth_ctrl_stats) 127 128 static const struct dpmac_counter dpaa2_mac_eth_mac_stats[] = { 129 DPMAC_MAC_COUNTER(DPMAC_CNT_EGR_GOOD_FRAME, FramesTransmittedOK), 130 DPMAC_MAC_COUNTER(DPMAC_CNT_ING_GOOD_FRAME, FramesReceivedOK), 131 DPMAC_MAC_COUNTER(DPMAC_CNT_ING_FCS_ERR, FrameCheckSequenceErrors), 132 DPMAC_MAC_COUNTER(DPMAC_CNT_ING_ALIGN_ERR, AlignmentErrors), 133 DPMAC_MAC_COUNTER(DPMAC_CNT_EGR_ALL_BYTE, OctetsTransmittedOK), 134 DPMAC_MAC_COUNTER(DPMAC_CNT_EGR_ERR_FRAME, FramesLostDueToIntMACXmitError), 135 DPMAC_MAC_COUNTER(DPMAC_CNT_ING_ALL_BYTE, OctetsReceivedOK), 136 DPMAC_MAC_COUNTER(DPMAC_CNT_ING_FRAME_DISCARD_NOT_TRUNC, FramesLostDueToIntMACRcvError), 137 DPMAC_MAC_COUNTER(DPMAC_CNT_EGR_MCAST_FRAME, MulticastFramesXmittedOK), 138 DPMAC_MAC_COUNTER(DPMAC_CNT_EGR_BCAST_FRAME, BroadcastFramesXmittedOK), 139 DPMAC_MAC_COUNTER(DPMAC_CNT_ING_MCAST_FRAME, MulticastFramesReceivedOK), 140 DPMAC_MAC_COUNTER(DPMAC_CNT_ING_BCAST_FRAME, BroadcastFramesReceivedOK), 141 }; 142 143 #define DPAA2_MAC_NUM_ETH_MAC_STATS ARRAY_SIZE(dpaa2_mac_eth_mac_stats) 144 145 static void dpaa2_mac_setup_stats(struct dpaa2_mac *mac, 146 struct dpaa2_mac_stats *stats, 147 size_t num_stats, 148 const struct dpmac_counter *counters) 149 { 150 struct device *dev = mac->net_dev->dev.parent; 151 size_t size_idx, size_values; 152 __le32 *cnt_idx; 153 154 size_idx = num_stats * sizeof(u32); 155 stats->idx_dma_mem = dma_alloc_noncoherent(dev, size_idx, 156 &stats->idx_iova, 157 DMA_TO_DEVICE, 158 GFP_KERNEL); 159 if (!stats->idx_dma_mem) 160 goto out; 161 162 size_values = num_stats * sizeof(u64); 163 stats->values_dma_mem = dma_alloc_noncoherent(dev, size_values, 164 &stats->values_iova, 165 DMA_FROM_DEVICE, 166 GFP_KERNEL); 167 if (!stats->values_dma_mem) 168 goto err_alloc_values; 169 170 cnt_idx = stats->idx_dma_mem; 171 for (size_t i = 0; i < num_stats; i++) 172 *cnt_idx++ = cpu_to_le32((u32)(counters[i].id)); 173 174 dma_sync_single_for_device(dev, stats->idx_iova, size_idx, 175 DMA_TO_DEVICE); 176 177 return; 178 179 err_alloc_values: 180 dma_free_noncoherent(dev, num_stats * sizeof(u32), stats->idx_dma_mem, 181 stats->idx_iova, DMA_TO_DEVICE); 182 out: 183 stats->idx_dma_mem = NULL; 184 stats->values_dma_mem = NULL; 185 } 186 187 static void dpaa2_mac_clear_stats(struct dpaa2_mac *mac, 188 struct dpaa2_mac_stats *stats, 189 size_t num_stats) 190 { 191 struct device *dev = mac->net_dev->dev.parent; 192 193 if (stats->idx_dma_mem) { 194 dma_free_noncoherent(dev, num_stats * sizeof(u32), 195 stats->idx_dma_mem, 196 stats->idx_iova, DMA_TO_DEVICE); 197 stats->idx_dma_mem = NULL; 198 } 199 200 if (stats->values_dma_mem) { 201 dma_free_noncoherent(dev, num_stats * sizeof(u64), 202 stats->values_dma_mem, 203 stats->values_iova, DMA_FROM_DEVICE); 204 stats->values_dma_mem = NULL; 205 } 206 } 207 208 static int dpaa2_mac_cmp_ver(struct dpaa2_mac *mac, 209 u16 ver_major, u16 ver_minor) 210 { 211 if (mac->ver_major == ver_major) 212 return mac->ver_minor - ver_minor; 213 return mac->ver_major - ver_major; 214 } 215 216 static void dpaa2_mac_detect_features(struct dpaa2_mac *mac) 217 { 218 mac->features = 0; 219 220 if (dpaa2_mac_cmp_ver(mac, DPMAC_PROTOCOL_CHANGE_VER_MAJOR, 221 DPMAC_PROTOCOL_CHANGE_VER_MINOR) >= 0) 222 mac->features |= DPAA2_MAC_FEATURE_PROTOCOL_CHANGE; 223 224 if (dpaa2_mac_cmp_ver(mac, DPMAC_STATS_BUNDLE_VER_MAJOR, 225 DPMAC_STATS_BUNDLE_VER_MINOR) >= 0) 226 mac->features |= DPAA2_MAC_FEATURE_STATS_BUNDLE; 227 228 if (dpaa2_mac_cmp_ver(mac, DPMAC_STANDARD_STATS_VER_MAJOR, 229 DPMAC_STANDARD_STATS_VER_MINOR) >= 0) 230 mac->features |= DPAA2_MAC_FEATURE_STANDARD_STATS; 231 } 232 233 static int phy_mode(enum dpmac_eth_if eth_if, phy_interface_t *if_mode) 234 { 235 *if_mode = PHY_INTERFACE_MODE_NA; 236 237 switch (eth_if) { 238 case DPMAC_ETH_IF_RGMII: 239 *if_mode = PHY_INTERFACE_MODE_RGMII; 240 break; 241 case DPMAC_ETH_IF_USXGMII: 242 *if_mode = PHY_INTERFACE_MODE_USXGMII; 243 break; 244 case DPMAC_ETH_IF_QSGMII: 245 *if_mode = PHY_INTERFACE_MODE_QSGMII; 246 break; 247 case DPMAC_ETH_IF_SGMII: 248 *if_mode = PHY_INTERFACE_MODE_SGMII; 249 break; 250 case DPMAC_ETH_IF_XFI: 251 *if_mode = PHY_INTERFACE_MODE_10GBASER; 252 break; 253 case DPMAC_ETH_IF_CAUI: 254 *if_mode = PHY_INTERFACE_MODE_25GBASER; 255 break; 256 default: 257 return -EINVAL; 258 } 259 260 return 0; 261 } 262 263 static enum dpmac_eth_if dpmac_eth_if_mode(phy_interface_t if_mode) 264 { 265 switch (if_mode) { 266 case PHY_INTERFACE_MODE_RGMII: 267 case PHY_INTERFACE_MODE_RGMII_ID: 268 case PHY_INTERFACE_MODE_RGMII_RXID: 269 case PHY_INTERFACE_MODE_RGMII_TXID: 270 return DPMAC_ETH_IF_RGMII; 271 case PHY_INTERFACE_MODE_USXGMII: 272 return DPMAC_ETH_IF_USXGMII; 273 case PHY_INTERFACE_MODE_QSGMII: 274 return DPMAC_ETH_IF_QSGMII; 275 case PHY_INTERFACE_MODE_SGMII: 276 return DPMAC_ETH_IF_SGMII; 277 case PHY_INTERFACE_MODE_10GBASER: 278 return DPMAC_ETH_IF_XFI; 279 case PHY_INTERFACE_MODE_1000BASEX: 280 return DPMAC_ETH_IF_1000BASEX; 281 case PHY_INTERFACE_MODE_25GBASER: 282 return DPMAC_ETH_IF_CAUI; 283 default: 284 return DPMAC_ETH_IF_MII; 285 } 286 } 287 288 static struct fwnode_handle *dpaa2_mac_get_node(struct device *dev, 289 u16 dpmac_id) 290 { 291 struct fwnode_handle *fwnode, *parent = NULL, *child = NULL; 292 struct device_node *dpmacs = NULL; 293 int err; 294 u32 id; 295 296 fwnode = dev_fwnode(dev->parent); 297 if (is_of_node(fwnode)) { 298 dpmacs = of_find_node_by_name(NULL, "dpmacs"); 299 if (!dpmacs) 300 return NULL; 301 parent = of_fwnode_handle(dpmacs); 302 } else if (is_acpi_node(fwnode)) { 303 parent = fwnode; 304 } else { 305 /* The root dprc device didn't yet get to finalize it's probe, 306 * thus the fwnode field is not yet set. Defer probe if we are 307 * facing this situation. 308 */ 309 dev_dbg(dev, "dprc not finished probing\n"); 310 return ERR_PTR(-EPROBE_DEFER); 311 } 312 313 fwnode_for_each_child_node(parent, child) { 314 err = -EINVAL; 315 if (is_acpi_device_node(child)) 316 err = acpi_get_local_address(ACPI_HANDLE_FWNODE(child), &id); 317 else if (is_of_node(child)) 318 err = of_property_read_u32(to_of_node(child), "reg", &id); 319 if (err) 320 continue; 321 322 if (id == dpmac_id) { 323 of_node_put(dpmacs); 324 return child; 325 } 326 } 327 of_node_put(dpmacs); 328 return NULL; 329 } 330 331 static int dpaa2_mac_get_if_mode(struct fwnode_handle *dpmac_node, 332 struct dpmac_attr attr) 333 { 334 phy_interface_t if_mode; 335 int err; 336 337 err = fwnode_get_phy_mode(dpmac_node); 338 if (err > 0) 339 return err; 340 341 err = phy_mode(attr.eth_if, &if_mode); 342 if (!err) 343 return if_mode; 344 345 return err; 346 } 347 348 static struct phylink_pcs *dpaa2_mac_select_pcs(struct phylink_config *config, 349 phy_interface_t interface) 350 { 351 struct dpaa2_mac *mac = phylink_to_dpaa2_mac(config); 352 353 return mac->pcs; 354 } 355 356 static void dpaa2_mac_config(struct phylink_config *config, unsigned int mode, 357 const struct phylink_link_state *state) 358 { 359 struct dpaa2_mac *mac = phylink_to_dpaa2_mac(config); 360 struct dpmac_link_state *dpmac_state = &mac->state; 361 int err; 362 363 if (linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, 364 state->advertising)) 365 dpmac_state->options |= DPMAC_LINK_OPT_AUTONEG; 366 else 367 dpmac_state->options &= ~DPMAC_LINK_OPT_AUTONEG; 368 369 err = dpmac_set_link_state(mac->mc_io, 0, 370 mac->mc_dev->mc_handle, dpmac_state); 371 if (err) 372 netdev_err(mac->net_dev, "%s: dpmac_set_link_state() = %d\n", 373 __func__, err); 374 375 if (!mac->serdes_phy) 376 return; 377 378 /* This happens only if we support changing of protocol at runtime */ 379 err = dpmac_set_protocol(mac->mc_io, 0, mac->mc_dev->mc_handle, 380 dpmac_eth_if_mode(state->interface)); 381 if (err) 382 netdev_err(mac->net_dev, "dpmac_set_protocol() = %d\n", err); 383 384 err = phy_set_mode_ext(mac->serdes_phy, PHY_MODE_ETHERNET, state->interface); 385 if (err) 386 netdev_err(mac->net_dev, "phy_set_mode_ext() = %d\n", err); 387 } 388 389 static void dpaa2_mac_link_up(struct phylink_config *config, 390 struct phy_device *phy, 391 unsigned int mode, phy_interface_t interface, 392 int speed, int duplex, 393 bool tx_pause, bool rx_pause) 394 { 395 struct dpaa2_mac *mac = phylink_to_dpaa2_mac(config); 396 struct dpmac_link_state *dpmac_state = &mac->state; 397 int err; 398 399 dpmac_state->up = 1; 400 401 dpmac_state->rate = speed; 402 403 if (duplex == DUPLEX_HALF) 404 dpmac_state->options |= DPMAC_LINK_OPT_HALF_DUPLEX; 405 else if (duplex == DUPLEX_FULL) 406 dpmac_state->options &= ~DPMAC_LINK_OPT_HALF_DUPLEX; 407 408 if (rx_pause) 409 dpmac_state->options |= DPMAC_LINK_OPT_PAUSE; 410 else 411 dpmac_state->options &= ~DPMAC_LINK_OPT_PAUSE; 412 413 if (rx_pause ^ tx_pause) 414 dpmac_state->options |= DPMAC_LINK_OPT_ASYM_PAUSE; 415 else 416 dpmac_state->options &= ~DPMAC_LINK_OPT_ASYM_PAUSE; 417 418 err = dpmac_set_link_state(mac->mc_io, 0, 419 mac->mc_dev->mc_handle, dpmac_state); 420 if (err) 421 netdev_err(mac->net_dev, "%s: dpmac_set_link_state() = %d\n", 422 __func__, err); 423 } 424 425 static void dpaa2_mac_link_down(struct phylink_config *config, 426 unsigned int mode, 427 phy_interface_t interface) 428 { 429 struct dpaa2_mac *mac = phylink_to_dpaa2_mac(config); 430 struct dpmac_link_state *dpmac_state = &mac->state; 431 int err; 432 433 dpmac_state->up = 0; 434 err = dpmac_set_link_state(mac->mc_io, 0, 435 mac->mc_dev->mc_handle, dpmac_state); 436 if (err) 437 netdev_err(mac->net_dev, "dpmac_set_link_state() = %d\n", err); 438 } 439 440 static const struct phylink_mac_ops dpaa2_mac_phylink_ops = { 441 .mac_select_pcs = dpaa2_mac_select_pcs, 442 .mac_config = dpaa2_mac_config, 443 .mac_link_up = dpaa2_mac_link_up, 444 .mac_link_down = dpaa2_mac_link_down, 445 }; 446 447 static int dpaa2_pcs_create(struct dpaa2_mac *mac, 448 struct fwnode_handle *dpmac_node, 449 int id) 450 { 451 struct fwnode_handle *node; 452 struct phylink_pcs *pcs; 453 454 node = fwnode_find_reference(dpmac_node, "pcs-handle", 0); 455 if (IS_ERR(node)) { 456 /* do not error out on old DTS files */ 457 netdev_warn(mac->net_dev, "pcs-handle node not found\n"); 458 return 0; 459 } 460 461 pcs = lynx_pcs_create_fwnode(node); 462 fwnode_handle_put(node); 463 464 if (pcs == ERR_PTR(-EPROBE_DEFER)) { 465 netdev_dbg(mac->net_dev, "missing PCS device\n"); 466 return -EPROBE_DEFER; 467 } 468 469 if (pcs == ERR_PTR(-ENODEV)) { 470 netdev_err(mac->net_dev, "pcs-handle node not available\n"); 471 return PTR_ERR(pcs); 472 } 473 474 if (IS_ERR(pcs)) { 475 netdev_err(mac->net_dev, 476 "lynx_pcs_create_fwnode() failed: %pe\n", pcs); 477 return PTR_ERR(pcs); 478 } 479 480 mac->pcs = pcs; 481 482 return 0; 483 } 484 485 static void dpaa2_pcs_destroy(struct dpaa2_mac *mac) 486 { 487 struct phylink_pcs *phylink_pcs = mac->pcs; 488 489 if (phylink_pcs) { 490 lynx_pcs_destroy(phylink_pcs); 491 mac->pcs = NULL; 492 } 493 } 494 495 static void dpaa2_mac_set_supported_interfaces(struct dpaa2_mac *mac) 496 { 497 int intf, err; 498 499 /* We support the current interface mode, and if we have a PCS 500 * similar interface modes that do not require the SerDes lane to be 501 * reconfigured. 502 */ 503 __set_bit(mac->if_mode, mac->phylink_config.supported_interfaces); 504 if (mac->pcs) { 505 switch (mac->if_mode) { 506 case PHY_INTERFACE_MODE_1000BASEX: 507 case PHY_INTERFACE_MODE_SGMII: 508 __set_bit(PHY_INTERFACE_MODE_1000BASEX, 509 mac->phylink_config.supported_interfaces); 510 __set_bit(PHY_INTERFACE_MODE_SGMII, 511 mac->phylink_config.supported_interfaces); 512 break; 513 514 default: 515 break; 516 } 517 } 518 519 if (!mac->serdes_phy) 520 return; 521 522 /* In case we have access to the SerDes phy/lane, then ask the SerDes 523 * driver what interfaces are supported based on the current PLL 524 * configuration. 525 */ 526 for (intf = 0; intf < PHY_INTERFACE_MODE_MAX; intf++) { 527 if (intf == PHY_INTERFACE_MODE_NA) 528 continue; 529 530 err = phy_validate(mac->serdes_phy, PHY_MODE_ETHERNET, intf, NULL); 531 if (err) 532 continue; 533 534 __set_bit(intf, mac->phylink_config.supported_interfaces); 535 } 536 } 537 538 void dpaa2_mac_start(struct dpaa2_mac *mac) 539 { 540 ASSERT_RTNL(); 541 542 if (mac->serdes_phy) 543 phy_power_on(mac->serdes_phy); 544 545 phylink_start(mac->phylink); 546 } 547 EXPORT_SYMBOL_GPL(dpaa2_mac_start); 548 549 void dpaa2_mac_stop(struct dpaa2_mac *mac) 550 { 551 ASSERT_RTNL(); 552 553 phylink_stop(mac->phylink); 554 555 if (mac->serdes_phy) 556 phy_power_off(mac->serdes_phy); 557 } 558 EXPORT_SYMBOL_GPL(dpaa2_mac_stop); 559 560 int dpaa2_mac_connect(struct dpaa2_mac *mac) 561 { 562 struct net_device *net_dev = mac->net_dev; 563 struct fwnode_handle *dpmac_node; 564 struct phy *serdes_phy = NULL; 565 struct phylink *phylink; 566 int err; 567 568 mac->if_link_type = mac->attr.link_type; 569 570 dpmac_node = mac->fw_node; 571 if (!dpmac_node) { 572 netdev_err(net_dev, "No dpmac@%d node found.\n", mac->attr.id); 573 return -ENODEV; 574 } 575 576 err = dpaa2_mac_get_if_mode(dpmac_node, mac->attr); 577 if (err < 0) 578 return -EINVAL; 579 mac->if_mode = err; 580 581 if (mac->features & DPAA2_MAC_FEATURE_PROTOCOL_CHANGE && 582 !phy_interface_mode_is_rgmii(mac->if_mode) && 583 is_of_node(dpmac_node)) { 584 serdes_phy = of_phy_get(to_of_node(dpmac_node), NULL); 585 586 if (serdes_phy == ERR_PTR(-ENODEV)) 587 serdes_phy = NULL; 588 else if (IS_ERR(serdes_phy)) 589 return PTR_ERR(serdes_phy); 590 else 591 phy_init(serdes_phy); 592 } 593 mac->serdes_phy = serdes_phy; 594 595 /* The MAC does not have the capability to add RGMII delays so 596 * error out if the interface mode requests them and there is no PHY 597 * to act upon them 598 */ 599 if (of_phy_is_fixed_link(to_of_node(dpmac_node)) && 600 (mac->if_mode == PHY_INTERFACE_MODE_RGMII_ID || 601 mac->if_mode == PHY_INTERFACE_MODE_RGMII_RXID || 602 mac->if_mode == PHY_INTERFACE_MODE_RGMII_TXID)) { 603 netdev_err(net_dev, "RGMII delay not supported\n"); 604 return -EINVAL; 605 } 606 607 if ((mac->attr.link_type == DPMAC_LINK_TYPE_PHY && 608 mac->attr.eth_if != DPMAC_ETH_IF_RGMII) || 609 mac->attr.link_type == DPMAC_LINK_TYPE_BACKPLANE) { 610 err = dpaa2_pcs_create(mac, dpmac_node, mac->attr.id); 611 if (err) 612 return err; 613 } 614 615 memset(&mac->phylink_config, 0, sizeof(mac->phylink_config)); 616 mac->phylink_config.dev = &net_dev->dev; 617 mac->phylink_config.type = PHYLINK_NETDEV; 618 619 mac->phylink_config.mac_capabilities = MAC_SYM_PAUSE | MAC_ASYM_PAUSE | 620 MAC_10FD | MAC_100FD | MAC_1000FD | MAC_2500FD | MAC_5000FD | 621 MAC_10000FD | MAC_25000FD; 622 623 dpaa2_mac_set_supported_interfaces(mac); 624 625 phylink = phylink_create(&mac->phylink_config, 626 dpmac_node, mac->if_mode, 627 &dpaa2_mac_phylink_ops); 628 if (IS_ERR(phylink)) { 629 err = PTR_ERR(phylink); 630 goto err_pcs_destroy; 631 } 632 mac->phylink = phylink; 633 634 rtnl_lock(); 635 err = phylink_fwnode_phy_connect(mac->phylink, dpmac_node, 0); 636 rtnl_unlock(); 637 if (err) { 638 netdev_err(net_dev, "phylink_fwnode_phy_connect() = %d\n", err); 639 goto err_phylink_destroy; 640 } 641 642 return 0; 643 644 err_phylink_destroy: 645 phylink_destroy(mac->phylink); 646 err_pcs_destroy: 647 dpaa2_pcs_destroy(mac); 648 649 return err; 650 } 651 EXPORT_SYMBOL_GPL(dpaa2_mac_connect); 652 653 void dpaa2_mac_disconnect(struct dpaa2_mac *mac) 654 { 655 rtnl_lock(); 656 phylink_disconnect_phy(mac->phylink); 657 rtnl_unlock(); 658 659 phylink_destroy(mac->phylink); 660 dpaa2_pcs_destroy(mac); 661 of_phy_put(mac->serdes_phy); 662 mac->serdes_phy = NULL; 663 } 664 EXPORT_SYMBOL_GPL(dpaa2_mac_disconnect); 665 666 int dpaa2_mac_open(struct dpaa2_mac *mac) 667 { 668 struct fsl_mc_device *dpmac_dev = mac->mc_dev; 669 struct net_device *net_dev = mac->net_dev; 670 struct fwnode_handle *fw_node; 671 int err; 672 673 err = dpmac_open(mac->mc_io, 0, dpmac_dev->obj_desc.id, 674 &dpmac_dev->mc_handle); 675 if (err || !dpmac_dev->mc_handle) { 676 netdev_err(net_dev, "dpmac_open() = %d\n", err); 677 return -ENODEV; 678 } 679 680 err = dpmac_get_attributes(mac->mc_io, 0, dpmac_dev->mc_handle, 681 &mac->attr); 682 if (err) { 683 netdev_err(net_dev, "dpmac_get_attributes() = %d\n", err); 684 goto err_close_dpmac; 685 } 686 687 err = dpmac_get_api_version(mac->mc_io, 0, &mac->ver_major, &mac->ver_minor); 688 if (err) { 689 netdev_err(net_dev, "dpmac_get_api_version() = %d\n", err); 690 goto err_close_dpmac; 691 } 692 693 dpaa2_mac_detect_features(mac); 694 695 /* Find the device node representing the MAC device and link the device 696 * behind the associated netdev to it. 697 */ 698 fw_node = dpaa2_mac_get_node(&mac->mc_dev->dev, mac->attr.id); 699 if (IS_ERR(fw_node)) { 700 err = PTR_ERR(fw_node); 701 goto err_close_dpmac; 702 } 703 704 mac->fw_node = fw_node; 705 net_dev->dev.of_node = to_of_node(mac->fw_node); 706 707 if (mac->features & DPAA2_MAC_FEATURE_STATS_BUNDLE) 708 dpaa2_mac_setup_stats(mac, &mac->ethtool_stats, 709 DPAA2_MAC_NUM_ETHTOOL_STATS, 710 dpaa2_mac_ethtool_stats); 711 712 if (mac->features & DPAA2_MAC_FEATURE_STANDARD_STATS) { 713 dpaa2_mac_setup_stats(mac, &mac->rmon_stats, 714 DPAA2_MAC_NUM_RMON_STATS, 715 dpaa2_mac_rmon_stats); 716 717 dpaa2_mac_setup_stats(mac, &mac->pause_stats, 718 DPAA2_MAC_NUM_PAUSE_STATS, 719 dpaa2_mac_pause_stats); 720 721 dpaa2_mac_setup_stats(mac, &mac->eth_ctrl_stats, 722 DPAA2_MAC_NUM_ETH_CTRL_STATS, 723 dpaa2_mac_eth_ctrl_stats); 724 725 dpaa2_mac_setup_stats(mac, &mac->eth_mac_stats, 726 DPAA2_MAC_NUM_ETH_MAC_STATS, 727 dpaa2_mac_eth_mac_stats); 728 } 729 730 return 0; 731 732 err_close_dpmac: 733 dpmac_close(mac->mc_io, 0, dpmac_dev->mc_handle); 734 return err; 735 } 736 EXPORT_SYMBOL_GPL(dpaa2_mac_open); 737 738 void dpaa2_mac_close(struct dpaa2_mac *mac) 739 { 740 struct fsl_mc_device *dpmac_dev = mac->mc_dev; 741 742 if (mac->features & DPAA2_MAC_FEATURE_STATS_BUNDLE) 743 dpaa2_mac_clear_stats(mac, &mac->ethtool_stats, 744 DPAA2_MAC_NUM_ETHTOOL_STATS); 745 746 if (mac->features & DPAA2_MAC_FEATURE_STANDARD_STATS) { 747 dpaa2_mac_clear_stats(mac, &mac->rmon_stats, 748 DPAA2_MAC_NUM_RMON_STATS); 749 dpaa2_mac_clear_stats(mac, &mac->pause_stats, 750 DPAA2_MAC_NUM_PAUSE_STATS); 751 dpaa2_mac_clear_stats(mac, &mac->eth_ctrl_stats, 752 DPAA2_MAC_NUM_ETH_CTRL_STATS); 753 dpaa2_mac_clear_stats(mac, &mac->eth_mac_stats, 754 DPAA2_MAC_NUM_ETH_MAC_STATS); 755 } 756 757 dpmac_close(mac->mc_io, 0, dpmac_dev->mc_handle); 758 if (mac->fw_node) 759 fwnode_handle_put(mac->fw_node); 760 } 761 EXPORT_SYMBOL_GPL(dpaa2_mac_close); 762 763 static void dpaa2_mac_transfer_stats(const struct dpmac_counter *counters, 764 size_t num_counters, void *s, 765 __le64 *cnt_values) 766 { 767 for (size_t i = 0; i < num_counters; i++) { 768 u64 *p = s + counters[i].offset; 769 770 *p = le64_to_cpu(cnt_values[i]); 771 } 772 } 773 774 static const struct ethtool_rmon_hist_range dpaa2_mac_rmon_ranges[] = { 775 { 64, 64 }, 776 { 65, 127 }, 777 { 128, 255 }, 778 { 256, 511 }, 779 { 512, 1023 }, 780 { 1024, 1518 }, 781 { 1519, DPAA2_ETH_MFL }, 782 {}, 783 }; 784 785 static void dpaa2_mac_get_standard_stats(struct dpaa2_mac *mac, 786 struct dpaa2_mac_stats *stats, 787 size_t num_cnt, 788 const struct dpmac_counter *counters, 789 void *s) 790 { 791 struct device *dev = mac->net_dev->dev.parent; 792 struct fsl_mc_device *dpmac_dev = mac->mc_dev; 793 size_t values_size = num_cnt * sizeof(u64); 794 int err; 795 796 if (!(mac->features & DPAA2_MAC_FEATURE_STANDARD_STATS)) 797 return; 798 799 if (!stats->idx_dma_mem || !stats->values_dma_mem) 800 return; 801 802 dma_sync_single_for_device(dev, stats->values_iova, values_size, 803 DMA_FROM_DEVICE); 804 805 err = dpmac_get_statistics(mac->mc_io, 0, dpmac_dev->mc_handle, 806 stats->idx_iova, stats->values_iova, 807 num_cnt); 808 if (err) { 809 netdev_err(mac->net_dev, "%s: dpmac_get_statistics() = %d\n", 810 __func__, err); 811 return; 812 } 813 814 dma_sync_single_for_cpu(dev, stats->values_iova, values_size, 815 DMA_FROM_DEVICE); 816 817 dpaa2_mac_transfer_stats(counters, num_cnt, s, stats->values_dma_mem); 818 } 819 820 void dpaa2_mac_get_rmon_stats(struct dpaa2_mac *mac, 821 struct ethtool_rmon_stats *s, 822 const struct ethtool_rmon_hist_range **ranges) 823 { 824 if (s->src != ETHTOOL_MAC_STATS_SRC_AGGREGATE) 825 return; 826 827 dpaa2_mac_get_standard_stats(mac, &mac->rmon_stats, 828 DPAA2_MAC_NUM_RMON_STATS, 829 dpaa2_mac_rmon_stats, s); 830 831 *ranges = dpaa2_mac_rmon_ranges; 832 } 833 EXPORT_SYMBOL_GPL(dpaa2_mac_get_rmon_stats); 834 835 void dpaa2_mac_get_pause_stats(struct dpaa2_mac *mac, 836 struct ethtool_pause_stats *s) 837 { 838 if (s->src != ETHTOOL_MAC_STATS_SRC_AGGREGATE) 839 return; 840 841 dpaa2_mac_get_standard_stats(mac, &mac->pause_stats, 842 DPAA2_MAC_NUM_PAUSE_STATS, 843 dpaa2_mac_pause_stats, s); 844 } 845 EXPORT_SYMBOL_GPL(dpaa2_mac_get_pause_stats); 846 847 void dpaa2_mac_get_ctrl_stats(struct dpaa2_mac *mac, 848 struct ethtool_eth_ctrl_stats *s) 849 { 850 if (s->src != ETHTOOL_MAC_STATS_SRC_AGGREGATE) 851 return; 852 853 dpaa2_mac_get_standard_stats(mac, &mac->eth_ctrl_stats, 854 DPAA2_MAC_NUM_ETH_CTRL_STATS, 855 dpaa2_mac_eth_ctrl_stats, s); 856 } 857 EXPORT_SYMBOL_GPL(dpaa2_mac_get_ctrl_stats); 858 859 void dpaa2_mac_get_eth_mac_stats(struct dpaa2_mac *mac, 860 struct ethtool_eth_mac_stats *s) 861 { 862 if (s->src != ETHTOOL_MAC_STATS_SRC_AGGREGATE) 863 return; 864 865 dpaa2_mac_get_standard_stats(mac, &mac->eth_mac_stats, 866 DPAA2_MAC_NUM_ETH_MAC_STATS, 867 dpaa2_mac_eth_mac_stats, s); 868 } 869 EXPORT_SYMBOL_GPL(dpaa2_mac_get_eth_mac_stats); 870 871 int dpaa2_mac_get_sset_count(void) 872 { 873 return DPAA2_MAC_NUM_ETHTOOL_STATS; 874 } 875 EXPORT_SYMBOL_GPL(dpaa2_mac_get_sset_count); 876 877 void dpaa2_mac_get_strings(u8 **data) 878 { 879 int i; 880 881 for (i = 0; i < DPAA2_MAC_NUM_ETHTOOL_STATS; i++) 882 ethtool_puts(data, dpaa2_mac_ethtool_stats[i].name); 883 } 884 EXPORT_SYMBOL_GPL(dpaa2_mac_get_strings); 885 886 void dpaa2_mac_get_ethtool_stats(struct dpaa2_mac *mac, u64 *data) 887 { 888 size_t values_size = DPAA2_MAC_NUM_ETHTOOL_STATS * sizeof(u64); 889 struct device *dev = mac->net_dev->dev.parent; 890 struct fsl_mc_device *dpmac_dev = mac->mc_dev; 891 __le64 *cnt_values; 892 int i, err; 893 u64 value; 894 895 if (!(mac->features & DPAA2_MAC_FEATURE_STATS_BUNDLE)) 896 goto fallback; 897 898 if (!mac->ethtool_stats.idx_dma_mem || 899 !mac->ethtool_stats.values_dma_mem) 900 goto fallback; 901 902 dma_sync_single_for_device(dev, mac->ethtool_stats.values_iova, 903 values_size, DMA_FROM_DEVICE); 904 905 err = dpmac_get_statistics(mac->mc_io, 0, dpmac_dev->mc_handle, 906 mac->ethtool_stats.idx_iova, 907 mac->ethtool_stats.values_iova, 908 DPAA2_MAC_NUM_ETHTOOL_STATS); 909 if (err) 910 goto fallback; 911 912 dma_sync_single_for_cpu(dev, mac->ethtool_stats.values_iova, 913 values_size, DMA_FROM_DEVICE); 914 915 cnt_values = mac->ethtool_stats.values_dma_mem; 916 for (i = 0; i < DPAA2_MAC_NUM_ETHTOOL_STATS; i++) 917 *(data + i) = le64_to_cpu(*cnt_values++); 918 919 return; 920 921 fallback: 922 923 /* Fallback and retrieve each counter one by one */ 924 for (i = 0; i < DPAA2_MAC_NUM_ETHTOOL_STATS; i++) { 925 err = dpmac_get_counter(mac->mc_io, 0, dpmac_dev->mc_handle, 926 dpaa2_mac_ethtool_stats[i].id, &value); 927 if (err) { 928 netdev_err_once(mac->net_dev, 929 "dpmac_get_counter error %d\n", err); 930 *(data + i) = U64_MAX; 931 continue; 932 } 933 *(data + i) = value; 934 } 935 } 936 EXPORT_SYMBOL_GPL(dpaa2_mac_get_ethtool_stats); 937 938 MODULE_LICENSE("GPL"); 939 MODULE_DESCRIPTION("DPAA2 Ethernet MAC library"); 940