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