drivers/net/ldpaa_eth/ldpaa_eth.c

   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 }