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