1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright 2014-2016 Freescale Semiconductor, Inc. 4 * Copyright 2017 NXP 5 */ 6 7 #include <common.h> 8 #include <asm/io.h> 9 #include <asm/types.h> 10 #include <malloc.h> 11 #include <net.h> 12 #include <hwconfig.h> 13 #include <phy.h> 14 #include <linux/compat.h> 15 #include <fsl-mc/fsl_dpmac.h> 16 17 #include <fsl-mc/ldpaa_wriop.h> 18 #include "ldpaa_eth.h" 19 20 #ifdef CONFIG_PHYLIB 21 static int init_phy(struct eth_device *dev) 22 { 23 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)dev->priv; 24 struct phy_device *phydev = NULL; 25 struct mii_dev *bus; 26 27 bus = wriop_get_mdio(priv->dpmac_id); 28 if (bus == NULL) 29 return 0; 30 31 phydev = phy_connect(bus, wriop_get_phy_address(priv->dpmac_id), 32 dev, wriop_get_enet_if(priv->dpmac_id)); 33 if (!phydev) { 34 printf("Failed to connect\n"); 35 return -1; 36 } 37 38 priv->phydev = phydev; 39 40 return phy_config(phydev); 41 } 42 #endif 43 44 #ifdef DEBUG 45 46 #define DPNI_STATS_PER_PAGE 6 47 48 static const char *dpni_statistics[][DPNI_STATS_PER_PAGE] = { 49 { 50 "DPNI_CNT_ING_ALL_FRAMES", 51 "DPNI_CNT_ING_ALL_BYTES", 52 "DPNI_CNT_ING_MCAST_FRAMES", 53 "DPNI_CNT_ING_MCAST_BYTES", 54 "DPNI_CNT_ING_BCAST_FRAMES", 55 "DPNI_CNT_ING_BCAST_BYTES", 56 }, { 57 "DPNI_CNT_EGR_ALL_FRAMES", 58 "DPNI_CNT_EGR_ALL_BYTES", 59 "DPNI_CNT_EGR_MCAST_FRAMES", 60 "DPNI_CNT_EGR_MCAST_BYTES", 61 "DPNI_CNT_EGR_BCAST_FRAMES", 62 "DPNI_CNT_EGR_BCAST_BYTES", 63 }, { 64 "DPNI_CNT_ING_FILTERED_FRAMES", 65 "DPNI_CNT_ING_DISCARDED_FRAMES", 66 "DPNI_CNT_ING_NOBUFFER_DISCARDS", 67 "DPNI_CNT_EGR_DISCARDED_FRAMES", 68 "DPNI_CNT_EGR_CNF_FRAMES", 69 "" 70 }, 71 }; 72 73 static void print_dpni_stats(const char *strings[], 74 struct dpni_statistics dpni_stats) 75 { 76 uint64_t *stat; 77 int i; 78 79 stat = (uint64_t *)&dpni_stats; 80 for (i = 0; i < DPNI_STATS_PER_PAGE; i++) { 81 if (strcmp(strings[i], "\0") == 0) 82 break; 83 printf("%s= %llu\n", strings[i], *stat); 84 stat++; 85 } 86 } 87 88 static void ldpaa_eth_get_dpni_counter(void) 89 { 90 int err = 0; 91 unsigned int page = 0; 92 struct dpni_statistics dpni_stats; 93 94 printf("DPNI counters ..\n"); 95 for (page = 0; page < 3; page++) { 96 err = dpni_get_statistics(dflt_mc_io, MC_CMD_NO_FLAGS, 97 dflt_dpni->dpni_handle, page, 98 &dpni_stats); 99 if (err < 0) { 100 printf("dpni_get_statistics: failed:"); 101 printf("%d for page[%d]\n", err, page); 102 return; 103 } 104 print_dpni_stats(dpni_statistics[page], dpni_stats); 105 } 106 } 107 108 static void ldpaa_eth_get_dpmac_counter(struct eth_device *net_dev) 109 { 110 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv; 111 int err = 0; 112 u64 value; 113 114 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS, 115 priv->dpmac_handle, 116 DPMAC_CNT_ING_BYTE, 117 &value); 118 if (err < 0) { 119 printf("dpmac_get_counter: DPMAC_CNT_ING_BYTE failed\n"); 120 return; 121 } 122 printf("\nDPMAC counters ..\n"); 123 printf("DPMAC_CNT_ING_BYTE=%lld\n", value); 124 125 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS, 126 priv->dpmac_handle, 127 DPMAC_CNT_ING_FRAME_DISCARD, 128 &value); 129 if (err < 0) { 130 printf("dpmac_get_counter: DPMAC_CNT_ING_FRAME_DISCARD failed\n"); 131 return; 132 } 133 printf("DPMAC_CNT_ING_FRAME_DISCARD=%lld\n", value); 134 135 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS, 136 priv->dpmac_handle, 137 DPMAC_CNT_ING_ALIGN_ERR, 138 &value); 139 if (err < 0) { 140 printf("dpmac_get_counter: DPMAC_CNT_ING_ALIGN_ERR failed\n"); 141 return; 142 } 143 printf("DPMAC_CNT_ING_ALIGN_ERR =%lld\n", value); 144 145 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS, 146 priv->dpmac_handle, 147 DPMAC_CNT_ING_BYTE, 148 &value); 149 if (err < 0) { 150 printf("dpmac_get_counter: DPMAC_CNT_ING_BYTE failed\n"); 151 return; 152 } 153 printf("DPMAC_CNT_ING_BYTE=%lld\n", value); 154 155 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS, 156 priv->dpmac_handle, 157 DPMAC_CNT_ING_ERR_FRAME, 158 &value); 159 if (err < 0) { 160 printf("dpmac_get_counter: DPMAC_CNT_ING_ERR_FRAME failed\n"); 161 return; 162 } 163 printf("DPMAC_CNT_ING_ERR_FRAME=%lld\n", value); 164 165 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS, 166 priv->dpmac_handle, 167 DPMAC_CNT_EGR_BYTE , 168 &value); 169 if (err < 0) { 170 printf("dpmac_get_counter: DPMAC_CNT_EGR_BYTE failed\n"); 171 return; 172 } 173 printf("DPMAC_CNT_EGR_BYTE =%lld\n", value); 174 175 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS, 176 priv->dpmac_handle, 177 DPMAC_CNT_EGR_ERR_FRAME , 178 &value); 179 if (err < 0) { 180 printf("dpmac_get_counter: DPMAC_CNT_EGR_ERR_FRAME failed\n"); 181 return; 182 } 183 printf("DPMAC_CNT_EGR_ERR_FRAME =%lld\n", value); 184 } 185 #endif 186 187 static void ldpaa_eth_rx(struct ldpaa_eth_priv *priv, 188 const struct dpaa_fd *fd) 189 { 190 u64 fd_addr; 191 uint16_t fd_offset; 192 uint32_t fd_length; 193 struct ldpaa_fas *fas; 194 uint32_t status, err; 195 u32 timeo = (CONFIG_SYS_HZ * 2) / 1000; 196 u32 time_start; 197 struct qbman_release_desc releasedesc; 198 struct qbman_swp *swp = dflt_dpio->sw_portal; 199 200 fd_addr = ldpaa_fd_get_addr(fd); 201 fd_offset = ldpaa_fd_get_offset(fd); 202 fd_length = ldpaa_fd_get_len(fd); 203 204 debug("Rx frame:data addr=0x%p size=0x%x\n", (u64 *)fd_addr, fd_length); 205 206 if (fd->simple.frc & LDPAA_FD_FRC_FASV) { 207 /* Read the frame annotation status word and check for errors */ 208 fas = (struct ldpaa_fas *) 209 ((uint8_t *)(fd_addr) + 210 dflt_dpni->buf_layout.private_data_size); 211 status = le32_to_cpu(fas->status); 212 if (status & LDPAA_ETH_RX_ERR_MASK) { 213 printf("Rx frame error(s): 0x%08x\n", 214 status & LDPAA_ETH_RX_ERR_MASK); 215 goto error; 216 } else if (status & LDPAA_ETH_RX_UNSUPP_MASK) { 217 printf("Unsupported feature in bitmask: 0x%08x\n", 218 status & LDPAA_ETH_RX_UNSUPP_MASK); 219 goto error; 220 } 221 } 222 223 debug("Rx frame: To Upper layer\n"); 224 net_process_received_packet((uint8_t *)(fd_addr) + fd_offset, 225 fd_length); 226 227 error: 228 flush_dcache_range(fd_addr, fd_addr + LDPAA_ETH_RX_BUFFER_SIZE); 229 qbman_release_desc_clear(&releasedesc); 230 qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid); 231 time_start = get_timer(0); 232 do { 233 /* Release buffer into the QBMAN */ 234 err = qbman_swp_release(swp, &releasedesc, &fd_addr, 1); 235 } while (get_timer(time_start) < timeo && err == -EBUSY); 236 237 if (err == -EBUSY) 238 printf("Rx frame: QBMAN buffer release fails\n"); 239 240 return; 241 } 242 243 static int ldpaa_eth_pull_dequeue_rx(struct eth_device *dev) 244 { 245 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)dev->priv; 246 const struct ldpaa_dq *dq; 247 const struct dpaa_fd *fd; 248 int i = 5, err = 0, status; 249 u32 timeo = (CONFIG_SYS_HZ * 2) / 1000; 250 u32 time_start; 251 static struct qbman_pull_desc pulldesc; 252 struct qbman_swp *swp = dflt_dpio->sw_portal; 253 254 while (--i) { 255 qbman_pull_desc_clear(&pulldesc); 256 qbman_pull_desc_set_numframes(&pulldesc, 1); 257 qbman_pull_desc_set_fq(&pulldesc, priv->rx_dflt_fqid); 258 259 err = qbman_swp_pull(swp, &pulldesc); 260 if (err < 0) { 261 printf("Dequeue frames error:0x%08x\n", err); 262 continue; 263 } 264 265 time_start = get_timer(0); 266 267 do { 268 dq = qbman_swp_dqrr_next(swp); 269 } while (get_timer(time_start) < timeo && !dq); 270 271 if (dq) { 272 /* Check for valid frame. If not sent a consume 273 * confirmation to QBMAN otherwise give it to NADK 274 * application and then send consume confirmation to 275 * QBMAN. 276 */ 277 status = (uint8_t)ldpaa_dq_flags(dq); 278 if ((status & LDPAA_DQ_STAT_VALIDFRAME) == 0) { 279 debug("Dequeue RX frames:"); 280 debug("No frame delivered\n"); 281 282 qbman_swp_dqrr_consume(swp, dq); 283 continue; 284 } 285 286 fd = ldpaa_dq_fd(dq); 287 288 /* Obtain FD and process it */ 289 ldpaa_eth_rx(priv, fd); 290 qbman_swp_dqrr_consume(swp, dq); 291 break; 292 } else { 293 err = -ENODATA; 294 debug("No DQRR entries\n"); 295 break; 296 } 297 } 298 299 return err; 300 } 301 302 static int ldpaa_eth_tx(struct eth_device *net_dev, void *buf, int len) 303 { 304 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv; 305 struct dpaa_fd fd; 306 u64 buffer_start; 307 int data_offset, err; 308 u32 timeo = (CONFIG_SYS_HZ * 10) / 1000; 309 u32 time_start; 310 struct qbman_swp *swp = dflt_dpio->sw_portal; 311 struct qbman_eq_desc ed; 312 struct qbman_release_desc releasedesc; 313 314 /* Setup the FD fields */ 315 memset(&fd, 0, sizeof(fd)); 316 317 data_offset = priv->tx_data_offset; 318 319 do { 320 err = qbman_swp_acquire(dflt_dpio->sw_portal, 321 dflt_dpbp->dpbp_attr.bpid, 322 &buffer_start, 1); 323 } while (err == -EBUSY); 324 325 if (err <= 0) { 326 printf("qbman_swp_acquire() failed\n"); 327 return -ENOMEM; 328 } 329 330 debug("TX data: malloc buffer start=0x%p\n", (u64 *)buffer_start); 331 332 memcpy(((uint8_t *)(buffer_start) + data_offset), buf, len); 333 334 flush_dcache_range(buffer_start, buffer_start + 335 LDPAA_ETH_RX_BUFFER_SIZE); 336 337 ldpaa_fd_set_addr(&fd, (u64)buffer_start); 338 ldpaa_fd_set_offset(&fd, (uint16_t)(data_offset)); 339 ldpaa_fd_set_bpid(&fd, dflt_dpbp->dpbp_attr.bpid); 340 ldpaa_fd_set_len(&fd, len); 341 342 fd.simple.ctrl = LDPAA_FD_CTRL_ASAL | LDPAA_FD_CTRL_PTA | 343 LDPAA_FD_CTRL_PTV1; 344 345 qbman_eq_desc_clear(&ed); 346 qbman_eq_desc_set_no_orp(&ed, 0); 347 qbman_eq_desc_set_qd(&ed, priv->tx_qdid, priv->tx_flow_id, 0); 348 349 time_start = get_timer(0); 350 351 while (get_timer(time_start) < timeo) { 352 err = qbman_swp_enqueue(swp, &ed, 353 (const struct qbman_fd *)(&fd)); 354 if (err != -EBUSY) 355 break; 356 } 357 358 if (err < 0) { 359 printf("error enqueueing Tx frame\n"); 360 goto error; 361 } 362 363 return err; 364 365 error: 366 qbman_release_desc_clear(&releasedesc); 367 qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid); 368 time_start = get_timer(0); 369 do { 370 /* Release buffer into the QBMAN */ 371 err = qbman_swp_release(swp, &releasedesc, &buffer_start, 1); 372 } while (get_timer(time_start) < timeo && err == -EBUSY); 373 374 if (err == -EBUSY) 375 printf("TX data: QBMAN buffer release fails\n"); 376 377 return err; 378 } 379 380 static int ldpaa_eth_open(struct eth_device *net_dev, bd_t *bd) 381 { 382 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv; 383 struct dpmac_link_state dpmac_link_state = { 0 }; 384 #ifdef DEBUG 385 struct dpni_link_state link_state; 386 #endif 387 int err = 0; 388 struct mii_dev *bus; 389 phy_interface_t enet_if; 390 struct dpni_queue d_queue; 391 392 if (net_dev->state == ETH_STATE_ACTIVE) 393 return 0; 394 395 if (get_mc_boot_status() != 0) { 396 printf("ERROR (MC is not booted)\n"); 397 return -ENODEV; 398 } 399 400 if (get_dpl_apply_status() == 0) { 401 printf("ERROR (DPL is deployed. No device available)\n"); 402 return -ENODEV; 403 } 404 405 /* DPMAC initialization */ 406 err = ldpaa_dpmac_setup(priv); 407 if (err < 0) 408 goto err_dpmac_setup; 409 410 #ifdef CONFIG_PHYLIB 411 if (priv->phydev) { 412 err = phy_startup(priv->phydev); 413 if (err) { 414 printf("%s: Could not initialize\n", 415 priv->phydev->dev->name); 416 goto err_dpamc_bind; 417 } 418 } 419 #else 420 priv->phydev = (struct phy_device *)malloc(sizeof(struct phy_device)); 421 memset(priv->phydev, 0, sizeof(struct phy_device)); 422 423 priv->phydev->speed = SPEED_1000; 424 priv->phydev->link = 1; 425 priv->phydev->duplex = DUPLEX_FULL; 426 #endif 427 428 bus = wriop_get_mdio(priv->dpmac_id); 429 enet_if = wriop_get_enet_if(priv->dpmac_id); 430 if ((bus == NULL) && 431 (enet_if == PHY_INTERFACE_MODE_XGMII)) { 432 priv->phydev = (struct phy_device *) 433 malloc(sizeof(struct phy_device)); 434 memset(priv->phydev, 0, sizeof(struct phy_device)); 435 436 priv->phydev->speed = SPEED_10000; 437 priv->phydev->link = 1; 438 priv->phydev->duplex = DUPLEX_FULL; 439 } 440 441 if (!priv->phydev->link) { 442 printf("%s: No link.\n", priv->phydev->dev->name); 443 err = -1; 444 goto err_dpamc_bind; 445 } 446 447 /* DPMAC binding DPNI */ 448 err = ldpaa_dpmac_bind(priv); 449 if (err) 450 goto err_dpamc_bind; 451 452 /* DPNI initialization */ 453 err = ldpaa_dpni_setup(priv); 454 if (err < 0) 455 goto err_dpni_setup; 456 457 err = ldpaa_dpbp_setup(); 458 if (err < 0) 459 goto err_dpbp_setup; 460 461 /* DPNI binding DPBP */ 462 err = ldpaa_dpni_bind(priv); 463 if (err) 464 goto err_dpni_bind; 465 466 err = dpni_add_mac_addr(dflt_mc_io, MC_CMD_NO_FLAGS, 467 dflt_dpni->dpni_handle, net_dev->enetaddr); 468 if (err) { 469 printf("dpni_add_mac_addr() failed\n"); 470 return err; 471 } 472 473 err = dpni_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle); 474 if (err < 0) { 475 printf("dpni_enable() failed\n"); 476 return err; 477 } 478 479 dpmac_link_state.rate = priv->phydev->speed; 480 481 if (priv->phydev->autoneg == AUTONEG_DISABLE) 482 dpmac_link_state.options &= ~DPMAC_LINK_OPT_AUTONEG; 483 else 484 dpmac_link_state.options |= DPMAC_LINK_OPT_AUTONEG; 485 486 if (priv->phydev->duplex == DUPLEX_HALF) 487 dpmac_link_state.options |= DPMAC_LINK_OPT_HALF_DUPLEX; 488 489 dpmac_link_state.up = priv->phydev->link; 490 491 err = dpmac_set_link_state(dflt_mc_io, MC_CMD_NO_FLAGS, 492 priv->dpmac_handle, &dpmac_link_state); 493 if (err < 0) { 494 printf("dpmac_set_link_state() failed\n"); 495 return err; 496 } 497 498 #ifdef DEBUG 499 printf("DPMAC link status: %d - ", dpmac_link_state.up); 500 dpmac_link_state.up == 0 ? printf("down\n") : 501 dpmac_link_state.up == 1 ? printf("up\n") : printf("error state\n"); 502 503 err = dpni_get_link_state(dflt_mc_io, MC_CMD_NO_FLAGS, 504 dflt_dpni->dpni_handle, &link_state); 505 if (err < 0) { 506 printf("dpni_get_link_state() failed\n"); 507 return err; 508 } 509 510 printf("DPNI link status: %d - ", link_state.up); 511 link_state.up == 0 ? printf("down\n") : 512 link_state.up == 1 ? printf("up\n") : printf("error state\n"); 513 #endif 514 515 memset(&d_queue, 0, sizeof(struct dpni_queue)); 516 err = dpni_get_queue(dflt_mc_io, MC_CMD_NO_FLAGS, 517 dflt_dpni->dpni_handle, DPNI_QUEUE_RX, 518 0, 0, &d_queue); 519 if (err) { 520 printf("dpni_get_queue failed\n"); 521 goto err_get_queue; 522 } 523 524 priv->rx_dflt_fqid = d_queue.fqid; 525 526 err = dpni_get_qdid(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle, 527 &priv->tx_qdid); 528 if (err) { 529 printf("dpni_get_qdid() failed\n"); 530 goto err_qdid; 531 } 532 533 return priv->phydev->link; 534 535 err_qdid: 536 err_get_queue: 537 dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle); 538 err_dpni_bind: 539 ldpaa_dpbp_free(); 540 err_dpbp_setup: 541 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle); 542 err_dpni_setup: 543 err_dpamc_bind: 544 dpmac_close(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle); 545 dpmac_destroy(dflt_mc_io, 546 dflt_dprc_handle, 547 MC_CMD_NO_FLAGS, priv->dpmac_id); 548 err_dpmac_setup: 549 return err; 550 } 551 552 static void ldpaa_eth_stop(struct eth_device *net_dev) 553 { 554 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv; 555 int err = 0; 556 #ifdef CONFIG_PHYLIB 557 struct mii_dev *bus = wriop_get_mdio(priv->dpmac_id); 558 #endif 559 560 if ((net_dev->state == ETH_STATE_PASSIVE) || 561 (net_dev->state == ETH_STATE_INIT)) 562 return; 563 564 #ifdef DEBUG 565 ldpaa_eth_get_dpni_counter(); 566 ldpaa_eth_get_dpmac_counter(net_dev); 567 #endif 568 569 err = dprc_disconnect(dflt_mc_io, MC_CMD_NO_FLAGS, 570 dflt_dprc_handle, &dpmac_endpoint); 571 if (err < 0) 572 printf("dprc_disconnect() failed dpmac_endpoint\n"); 573 574 err = dpmac_close(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle); 575 if (err < 0) 576 printf("dpmac_close() failed\n"); 577 578 err = dpmac_destroy(dflt_mc_io, 579 dflt_dprc_handle, 580 MC_CMD_NO_FLAGS, 581 priv->dpmac_id); 582 if (err < 0) 583 printf("dpmac_destroy() failed\n"); 584 585 /* Stop Tx and Rx traffic */ 586 err = dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle); 587 if (err < 0) 588 printf("dpni_disable() failed\n"); 589 590 #ifdef CONFIG_PHYLIB 591 if (priv->phydev && bus != NULL) 592 phy_shutdown(priv->phydev); 593 else { 594 free(priv->phydev); 595 priv->phydev = NULL; 596 } 597 #endif 598 599 /* Free DPBP handle and reset. */ 600 ldpaa_dpbp_free(); 601 602 dpni_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle); 603 if (err < 0) 604 printf("dpni_reset() failed\n"); 605 606 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle); 607 if (err < 0) 608 printf("dpni_close() failed\n"); 609 } 610 611 static void ldpaa_dpbp_drain_cnt(int count) 612 { 613 uint64_t buf_array[7]; 614 void *addr; 615 int ret, i; 616 617 BUG_ON(count > 7); 618 619 do { 620 ret = qbman_swp_acquire(dflt_dpio->sw_portal, 621 dflt_dpbp->dpbp_attr.bpid, 622 buf_array, count); 623 if (ret < 0) { 624 printf("qbman_swp_acquire() failed\n"); 625 return; 626 } 627 for (i = 0; i < ret; i++) { 628 addr = (void *)buf_array[i]; 629 debug("Free: buffer addr =0x%p\n", addr); 630 free(addr); 631 } 632 } while (ret); 633 } 634 635 static void ldpaa_dpbp_drain(void) 636 { 637 int i; 638 for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7) 639 ldpaa_dpbp_drain_cnt(7); 640 } 641 642 static int ldpaa_bp_add_7(uint16_t bpid) 643 { 644 uint64_t buf_array[7]; 645 u8 *addr; 646 int i; 647 struct qbman_release_desc rd; 648 649 for (i = 0; i < 7; i++) { 650 addr = memalign(LDPAA_ETH_BUF_ALIGN, LDPAA_ETH_RX_BUFFER_SIZE); 651 if (!addr) { 652 printf("addr allocation failed\n"); 653 goto err_alloc; 654 } 655 memset(addr, 0x00, LDPAA_ETH_RX_BUFFER_SIZE); 656 flush_dcache_range((u64)addr, 657 (u64)(addr + LDPAA_ETH_RX_BUFFER_SIZE)); 658 659 buf_array[i] = (uint64_t)addr; 660 debug("Release: buffer addr =0x%p\n", addr); 661 } 662 663 release_bufs: 664 /* In case the portal is busy, retry until successful. 665 * This function is guaranteed to succeed in a reasonable amount 666 * of time. 667 */ 668 669 do { 670 mdelay(1); 671 qbman_release_desc_clear(&rd); 672 qbman_release_desc_set_bpid(&rd, bpid); 673 } while (qbman_swp_release(dflt_dpio->sw_portal, &rd, buf_array, i)); 674 675 return i; 676 677 err_alloc: 678 if (i) 679 goto release_bufs; 680 681 return 0; 682 } 683 684 static int ldpaa_dpbp_seed(uint16_t bpid) 685 { 686 int i; 687 int count; 688 689 for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7) { 690 count = ldpaa_bp_add_7(bpid); 691 if (count < 7) 692 printf("Buffer Seed= %d\n", count); 693 } 694 695 return 0; 696 } 697 698 static int ldpaa_dpbp_setup(void) 699 { 700 int err; 701 702 err = dpbp_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_attr.id, 703 &dflt_dpbp->dpbp_handle); 704 if (err) { 705 printf("dpbp_open() failed\n"); 706 goto err_open; 707 } 708 709 err = dpbp_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle); 710 if (err) { 711 printf("dpbp_enable() failed\n"); 712 goto err_enable; 713 } 714 715 err = dpbp_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS, 716 dflt_dpbp->dpbp_handle, 717 &dflt_dpbp->dpbp_attr); 718 if (err) { 719 printf("dpbp_get_attributes() failed\n"); 720 goto err_get_attr; 721 } 722 723 err = ldpaa_dpbp_seed(dflt_dpbp->dpbp_attr.bpid); 724 725 if (err) { 726 printf("Buffer seeding failed for DPBP %d (bpid=%d)\n", 727 dflt_dpbp->dpbp_attr.id, dflt_dpbp->dpbp_attr.bpid); 728 goto err_seed; 729 } 730 731 return 0; 732 733 err_seed: 734 err_get_attr: 735 dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle); 736 err_enable: 737 dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle); 738 err_open: 739 return err; 740 } 741 742 static void ldpaa_dpbp_free(void) 743 { 744 ldpaa_dpbp_drain(); 745 dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle); 746 dpbp_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle); 747 dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle); 748 } 749 750 static int ldpaa_dpmac_version_check(struct fsl_mc_io *mc_io, 751 struct ldpaa_eth_priv *priv) 752 { 753 int error; 754 uint16_t major_ver, minor_ver; 755 756 error = dpmac_get_api_version(dflt_mc_io, 0, 757 &major_ver, 758 &minor_ver); 759 if ((major_ver < DPMAC_VER_MAJOR) || 760 (major_ver == DPMAC_VER_MAJOR && minor_ver < DPMAC_VER_MINOR)) { 761 printf("DPMAC version mismatch found %u.%u,", 762 major_ver, minor_ver); 763 printf("supported version is %u.%u\n", 764 DPMAC_VER_MAJOR, DPMAC_VER_MINOR); 765 return error; 766 } 767 768 return error; 769 } 770 771 static int ldpaa_dpmac_setup(struct ldpaa_eth_priv *priv) 772 { 773 int err = 0; 774 struct dpmac_cfg dpmac_cfg; 775 776 dpmac_cfg.mac_id = priv->dpmac_id; 777 778 err = dpmac_create(dflt_mc_io, 779 dflt_dprc_handle, 780 MC_CMD_NO_FLAGS, &dpmac_cfg, 781 &priv->dpmac_id); 782 if (err) 783 printf("dpmac_create() failed\n"); 784 785 err = ldpaa_dpmac_version_check(dflt_mc_io, priv); 786 if (err < 0) { 787 printf("ldpaa_dpmac_version_check() failed: %d\n", err); 788 goto err_version_check; 789 } 790 791 err = dpmac_open(dflt_mc_io, 792 MC_CMD_NO_FLAGS, 793 priv->dpmac_id, 794 &priv->dpmac_handle); 795 if (err < 0) { 796 printf("dpmac_open() failed: %d\n", err); 797 goto err_open; 798 } 799 800 return err; 801 802 err_open: 803 err_version_check: 804 dpmac_destroy(dflt_mc_io, 805 dflt_dprc_handle, 806 MC_CMD_NO_FLAGS, priv->dpmac_id); 807 808 return err; 809 } 810 811 static int ldpaa_dpmac_bind(struct ldpaa_eth_priv *priv) 812 { 813 int err = 0; 814 struct dprc_connection_cfg dprc_connection_cfg = { 815 /* If both rates are zero the connection */ 816 /* will be configured in "best effort" mode. */ 817 .committed_rate = 0, 818 .max_rate = 0 819 }; 820 821 #ifdef DEBUG 822 struct dprc_endpoint dbg_endpoint; 823 int state = 0; 824 #endif 825 826 memset(&dpmac_endpoint, 0, sizeof(struct dprc_endpoint)); 827 strcpy(dpmac_endpoint.type, "dpmac"); 828 dpmac_endpoint.id = priv->dpmac_id; 829 830 memset(&dpni_endpoint, 0, sizeof(struct dprc_endpoint)); 831 strcpy(dpni_endpoint.type, "dpni"); 832 dpni_endpoint.id = dflt_dpni->dpni_id; 833 834 err = dprc_connect(dflt_mc_io, MC_CMD_NO_FLAGS, 835 dflt_dprc_handle, 836 &dpmac_endpoint, 837 &dpni_endpoint, 838 &dprc_connection_cfg); 839 if (err) 840 printf("dprc_connect() failed\n"); 841 842 #ifdef DEBUG 843 err = dprc_get_connection(dflt_mc_io, MC_CMD_NO_FLAGS, 844 dflt_dprc_handle, &dpni_endpoint, 845 &dbg_endpoint, &state); 846 printf("%s, DPMAC Type= %s\n", __func__, dbg_endpoint.type); 847 printf("%s, DPMAC ID= %d\n", __func__, dbg_endpoint.id); 848 printf("%s, DPMAC State= %d\n", __func__, state); 849 850 memset(&dbg_endpoint, 0, sizeof(struct dprc_endpoint)); 851 err = dprc_get_connection(dflt_mc_io, MC_CMD_NO_FLAGS, 852 dflt_dprc_handle, &dpmac_endpoint, 853 &dbg_endpoint, &state); 854 printf("%s, DPNI Type= %s\n", __func__, dbg_endpoint.type); 855 printf("%s, DPNI ID= %d\n", __func__, dbg_endpoint.id); 856 printf("%s, DPNI State= %d\n", __func__, state); 857 #endif 858 return err; 859 } 860 861 static int ldpaa_dpni_setup(struct ldpaa_eth_priv *priv) 862 { 863 int err; 864 865 /* and get a handle for the DPNI this interface is associate with */ 866 err = dpni_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_id, 867 &dflt_dpni->dpni_handle); 868 if (err) { 869 printf("dpni_open() failed\n"); 870 goto err_open; 871 } 872 err = dpni_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS, 873 dflt_dpni->dpni_handle, 874 &dflt_dpni->dpni_attrs); 875 if (err) { 876 printf("dpni_get_attributes() failed (err=%d)\n", err); 877 goto err_get_attr; 878 } 879 880 /* Configure our buffers' layout */ 881 dflt_dpni->buf_layout.options = DPNI_BUF_LAYOUT_OPT_PARSER_RESULT | 882 DPNI_BUF_LAYOUT_OPT_FRAME_STATUS | 883 DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE | 884 DPNI_BUF_LAYOUT_OPT_DATA_ALIGN; 885 dflt_dpni->buf_layout.pass_parser_result = true; 886 dflt_dpni->buf_layout.pass_frame_status = true; 887 dflt_dpni->buf_layout.private_data_size = LDPAA_ETH_SWA_SIZE; 888 /* HW erratum mandates data alignment in multiples of 256 */ 889 dflt_dpni->buf_layout.data_align = LDPAA_ETH_BUF_ALIGN; 890 891 /* ...rx, ... */ 892 err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS, 893 dflt_dpni->dpni_handle, 894 &dflt_dpni->buf_layout, DPNI_QUEUE_RX); 895 if (err) { 896 printf("dpni_set_buffer_layout() failed"); 897 goto err_buf_layout; 898 } 899 900 /* ... tx, ... */ 901 /* remove Rx-only options */ 902 dflt_dpni->buf_layout.options &= ~(DPNI_BUF_LAYOUT_OPT_DATA_ALIGN | 903 DPNI_BUF_LAYOUT_OPT_PARSER_RESULT); 904 err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS, 905 dflt_dpni->dpni_handle, 906 &dflt_dpni->buf_layout, DPNI_QUEUE_TX); 907 if (err) { 908 printf("dpni_set_buffer_layout() failed"); 909 goto err_buf_layout; 910 } 911 912 /* ... tx-confirm. */ 913 dflt_dpni->buf_layout.options &= ~DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE; 914 err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS, 915 dflt_dpni->dpni_handle, 916 &dflt_dpni->buf_layout, 917 DPNI_QUEUE_TX_CONFIRM); 918 if (err) { 919 printf("dpni_set_buffer_layout() failed"); 920 goto err_buf_layout; 921 } 922 923 /* Now that we've set our tx buffer layout, retrieve the minimum 924 * required tx data offset. 925 */ 926 err = dpni_get_tx_data_offset(dflt_mc_io, MC_CMD_NO_FLAGS, 927 dflt_dpni->dpni_handle, 928 &priv->tx_data_offset); 929 if (err) { 930 printf("dpni_get_tx_data_offset() failed\n"); 931 goto err_data_offset; 932 } 933 934 /* Warn in case TX data offset is not multiple of 64 bytes. */ 935 WARN_ON(priv->tx_data_offset % 64); 936 937 /* Accomodate SWA space. */ 938 priv->tx_data_offset += LDPAA_ETH_SWA_SIZE; 939 debug("priv->tx_data_offset=%d\n", priv->tx_data_offset); 940 941 return 0; 942 943 err_data_offset: 944 err_buf_layout: 945 err_get_attr: 946 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle); 947 err_open: 948 return err; 949 } 950 951 static int ldpaa_dpni_bind(struct ldpaa_eth_priv *priv) 952 { 953 struct dpni_pools_cfg pools_params; 954 struct dpni_queue tx_queue; 955 int err = 0; 956 957 memset(&pools_params, 0, sizeof(pools_params)); 958 pools_params.num_dpbp = 1; 959 pools_params.pools[0].dpbp_id = (uint16_t)dflt_dpbp->dpbp_attr.id; 960 pools_params.pools[0].buffer_size = LDPAA_ETH_RX_BUFFER_SIZE; 961 err = dpni_set_pools(dflt_mc_io, MC_CMD_NO_FLAGS, 962 dflt_dpni->dpni_handle, &pools_params); 963 if (err) { 964 printf("dpni_set_pools() failed\n"); 965 return err; 966 } 967 968 memset(&tx_queue, 0, sizeof(struct dpni_queue)); 969 970 err = dpni_set_queue(dflt_mc_io, MC_CMD_NO_FLAGS, 971 dflt_dpni->dpni_handle, 972 DPNI_QUEUE_TX, 0, 0, &tx_queue); 973 974 if (err) { 975 printf("dpni_set_queue() failed\n"); 976 return err; 977 } 978 979 err = dpni_set_tx_confirmation_mode(dflt_mc_io, MC_CMD_NO_FLAGS, 980 dflt_dpni->dpni_handle, 981 DPNI_CONF_DISABLE); 982 if (err) { 983 printf("dpni_set_tx_confirmation_mode() failed\n"); 984 return err; 985 } 986 987 return 0; 988 } 989 990 static int ldpaa_eth_netdev_init(struct eth_device *net_dev, 991 phy_interface_t enet_if) 992 { 993 int err; 994 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv; 995 996 sprintf(net_dev->name, "DPMAC%d@%s", priv->dpmac_id, 997 phy_interface_strings[enet_if]); 998 999 net_dev->iobase = 0; 1000 net_dev->init = ldpaa_eth_open; 1001 net_dev->halt = ldpaa_eth_stop; 1002 net_dev->send = ldpaa_eth_tx; 1003 net_dev->recv = ldpaa_eth_pull_dequeue_rx; 1004 1005 #ifdef CONFIG_PHYLIB 1006 err = init_phy(net_dev); 1007 if (err < 0) 1008 return err; 1009 #endif 1010 1011 err = eth_register(net_dev); 1012 if (err < 0) { 1013 printf("eth_register() = %d\n", err); 1014 return err; 1015 } 1016 1017 return 0; 1018 } 1019 1020 int ldpaa_eth_init(int dpmac_id, phy_interface_t enet_if) 1021 { 1022 struct eth_device *net_dev = NULL; 1023 struct ldpaa_eth_priv *priv = NULL; 1024 int err = 0; 1025 1026 /* Net device */ 1027 net_dev = (struct eth_device *)malloc(sizeof(struct eth_device)); 1028 if (!net_dev) { 1029 printf("eth_device malloc() failed\n"); 1030 return -ENOMEM; 1031 } 1032 memset(net_dev, 0, sizeof(struct eth_device)); 1033 1034 /* alloc the ldpaa ethernet private struct */ 1035 priv = (struct ldpaa_eth_priv *)malloc(sizeof(struct ldpaa_eth_priv)); 1036 if (!priv) { 1037 printf("ldpaa_eth_priv malloc() failed\n"); 1038 return -ENOMEM; 1039 } 1040 memset(priv, 0, sizeof(struct ldpaa_eth_priv)); 1041 1042 net_dev->priv = (void *)priv; 1043 priv->net_dev = (struct eth_device *)net_dev; 1044 priv->dpmac_id = dpmac_id; 1045 debug("%s dpmac_id=%d\n", __func__, dpmac_id); 1046 1047 err = ldpaa_eth_netdev_init(net_dev, enet_if); 1048 if (err) 1049 goto err_netdev_init; 1050 1051 debug("ldpaa ethernet: Probed interface %s\n", net_dev->name); 1052 return 0; 1053 1054 err_netdev_init: 1055 free(priv); 1056 net_dev->priv = NULL; 1057 free(net_dev); 1058 1059 return err; 1060 } 1061