git.sur5r.net Git - u-boot/blob - drivers/net/ldpaa_eth/ldpaa_eth.c

   1 /*
   2  * Copyright (C) 2014 Freescale Semiconductor
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   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 "ldpaa_eth.h"
  18
  19 #undef CONFIG_PHYLIB
  20 static int init_phy(struct eth_device *dev)
  21 {
  22         /*TODO for external PHY */
  23
  24         return 0;
  25 }
  26
  27 #ifdef DEBUG
  28 static void ldpaa_eth_get_dpni_counter(void)
  29 {
  30         int err = 0;
  31         u64 value;
  32
  33         err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
  34                      dflt_dpni->dpni_handle,
  35                      DPNI_CNT_ING_FRAME,
  36                      &value);
  37         if (err < 0) {
  38                 printf("dpni_get_counter: DPNI_CNT_ING_FRAME failed\n");
  39                 return;
  40         }
  41         printf("DPNI_CNT_ING_FRAME=%lld\n", value);
  42
  43         err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
  44                      dflt_dpni->dpni_handle,
  45                      DPNI_CNT_ING_BYTE,
  46                      &value);
  47         if (err < 0) {
  48                 printf("dpni_get_counter: DPNI_CNT_ING_BYTE failed\n");
  49                 return;
  50         }
  51         printf("DPNI_CNT_ING_BYTE=%lld\n", value);
  52
  53         err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
  54                      dflt_dpni->dpni_handle,
  55                      DPNI_CNT_ING_FRAME_DROP ,
  56                      &value);
  57         if (err < 0) {
  58                 printf("dpni_get_counter: DPNI_CNT_ING_FRAME_DROP failed\n");
  59                 return;
  60         }
  61         printf("DPNI_CNT_ING_FRAME_DROP =%lld\n", value);
  62
  63         err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
  64                      dflt_dpni->dpni_handle,
  65                      DPNI_CNT_ING_FRAME_DISCARD,
  66                      &value);
  67         if (err < 0) {
  68                 printf("dpni_get_counter: DPNI_CNT_ING_FRAME_DISCARD failed\n");
  69                 return;
  70         }
  71         printf("DPNI_CNT_ING_FRAME_DISCARD=%lld\n", value);
  72
  73         err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
  74                      dflt_dpni->dpni_handle,
  75                      DPNI_CNT_EGR_FRAME,
  76                      &value);
  77         if (err < 0) {
  78                 printf("dpni_get_counter: DPNI_CNT_EGR_FRAME failed\n");
  79                 return;
  80         }
  81         printf("DPNI_CNT_EGR_FRAME=%lld\n", value);
  82
  83         err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
  84                      dflt_dpni->dpni_handle,
  85                      DPNI_CNT_EGR_BYTE ,
  86                      &value);
  87         if (err < 0) {
  88                 printf("dpni_get_counter: DPNI_CNT_EGR_BYTE failed\n");
  89                 return;
  90         }
  91         printf("DPNI_CNT_EGR_BYTE =%lld\n", value);
  92
  93         err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
  94                      dflt_dpni->dpni_handle,
  95                      DPNI_CNT_EGR_FRAME_DISCARD ,
  96                      &value);
  97         if (err < 0) {
  98                 printf("dpni_get_counter: DPNI_CNT_EGR_FRAME_DISCARD failed\n");
  99                 return;
 100         }
 101         printf("DPNI_CNT_EGR_FRAME_DISCARD =%lld\n", value);
 102 }
 103 #endif
 104
 105 static void ldpaa_eth_rx(struct ldpaa_eth_priv *priv,
 106                          const struct dpaa_fd *fd)
 107 {
 108         u64 fd_addr;
 109         uint16_t fd_offset;
 110         uint32_t fd_length;
 111         struct ldpaa_fas *fas;
 112         uint32_t status, err;
 113         u32 timeo = (CONFIG_SYS_HZ * 2) / 1000;
 114         u32 time_start;
 115         struct qbman_release_desc releasedesc;
 116         struct qbman_swp *swp = dflt_dpio->sw_portal;
 117
 118         fd_addr = ldpaa_fd_get_addr(fd);
 119         fd_offset = ldpaa_fd_get_offset(fd);
 120         fd_length = ldpaa_fd_get_len(fd);
 121
 122         debug("Rx frame:data addr=0x%p size=0x%x\n", (u64 *)fd_addr, fd_length);
 123
 124         if (fd->simple.frc & LDPAA_FD_FRC_FASV) {
 125                 /* Read the frame annotation status word and check for errors */
 126                 fas = (struct ldpaa_fas *)
 127                                 ((uint8_t *)(fd_addr) +
 128                                 dflt_dpni->buf_layout.private_data_size);
 129                 status = le32_to_cpu(fas->status);
 130                 if (status & LDPAA_ETH_RX_ERR_MASK) {
 131                         printf("Rx frame error(s): 0x%08x\n",
 132                                status & LDPAA_ETH_RX_ERR_MASK);
 133                         goto error;
 134                 } else if (status & LDPAA_ETH_RX_UNSUPP_MASK) {
 135                         printf("Unsupported feature in bitmask: 0x%08x\n",
 136                                status & LDPAA_ETH_RX_UNSUPP_MASK);
 137                         goto error;
 138                 }
 139         }
 140
 141         debug("Rx frame: To Upper layer\n");
 142         net_process_received_packet((uint8_t *)(fd_addr) + fd_offset,
 143                                     fd_length);
 144
 145 error:
 146         flush_dcache_range(fd_addr, fd_addr + LDPAA_ETH_RX_BUFFER_SIZE);
 147         qbman_release_desc_clear(&releasedesc);
 148         qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid);
 149         time_start = get_timer(0);
 150         do {
 151                 /* Release buffer into the QBMAN */
 152                 err = qbman_swp_release(swp, &releasedesc, &fd_addr, 1);
 153         } while (get_timer(time_start) < timeo && err == -EBUSY);
 154
 155         if (err == -EBUSY)
 156                 printf("Rx frame: QBMAN buffer release fails\n");
 157
 158         return;
 159 }
 160
 161 static int ldpaa_eth_pull_dequeue_rx(struct eth_device *dev)
 162 {
 163         struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)dev->priv;
 164         const struct ldpaa_dq *dq;
 165         const struct dpaa_fd *fd;
 166         int i = 5, err = 0, status;
 167         u32 timeo = (CONFIG_SYS_HZ * 2) / 1000;
 168         u32 time_start;
 169         static struct qbman_pull_desc pulldesc;
 170         struct qbman_swp *swp = dflt_dpio->sw_portal;
 171
 172         while (--i) {
 173                 qbman_pull_desc_clear(&pulldesc);
 174                 qbman_pull_desc_set_numframes(&pulldesc, 1);
 175                 qbman_pull_desc_set_fq(&pulldesc, priv->rx_dflt_fqid);
 176
 177                 err = qbman_swp_pull(swp, &pulldesc);
 178                 if (err < 0) {
 179                         printf("Dequeue frames error:0x%08x\n", err);
 180                         continue;
 181                 }
 182
 183                 time_start = get_timer(0);
 184
 185                  do {
 186                         dq = qbman_swp_dqrr_next(swp);
 187                 } while (get_timer(time_start) < timeo && !dq);
 188
 189                 if (dq) {
 190                         /* Check for valid frame. If not sent a consume
 191                          * confirmation to QBMAN otherwise give it to NADK
 192                          * application and then send consume confirmation to
 193                          * QBMAN.
 194                          */
 195                         status = (uint8_t)ldpaa_dq_flags(dq);
 196                         if ((status & LDPAA_DQ_STAT_VALIDFRAME) == 0) {
 197                                 debug("Dequeue RX frames:");
 198                                 debug("No frame delivered\n");
 199
 200                                 qbman_swp_dqrr_consume(swp, dq);
 201                                 continue;
 202                         }
 203
 204                         fd = ldpaa_dq_fd(dq);
 205
 206                         /* Obtain FD and process it */
 207                         ldpaa_eth_rx(priv, fd);
 208                         qbman_swp_dqrr_consume(swp, dq);
 209                         break;
 210                 } else {
 211                         err = -ENODATA;
 212                         debug("No DQRR entries\n");
 213                         break;
 214                 }
 215         }
 216
 217         return err;
 218 }
 219
 220 static int ldpaa_eth_tx(struct eth_device *net_dev, void *buf, int len)
 221 {
 222         struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
 223         struct dpaa_fd fd;
 224         u64 buffer_start;
 225         int data_offset, err;
 226         u32 timeo = (CONFIG_SYS_HZ * 10) / 1000;
 227         u32 time_start;
 228         struct qbman_swp *swp = dflt_dpio->sw_portal;
 229         struct qbman_eq_desc ed;
 230         struct qbman_release_desc releasedesc;
 231
 232         /* Setup the FD fields */
 233         memset(&fd, 0, sizeof(fd));
 234
 235         data_offset = priv->tx_data_offset;
 236
 237         do {
 238                 err = qbman_swp_acquire(dflt_dpio->sw_portal,
 239                                         dflt_dpbp->dpbp_attr.bpid,
 240                                         &buffer_start, 1);
 241         } while (err == -EBUSY);
 242
 243         if (err < 0) {
 244                 printf("qbman_swp_acquire() failed\n");
 245                 return -ENOMEM;
 246         }
 247
 248         debug("TX data: malloc buffer start=0x%p\n", (u64 *)buffer_start);
 249
 250         memcpy(((uint8_t *)(buffer_start) + data_offset), buf, len);
 251
 252         flush_dcache_range(buffer_start, buffer_start +
 253                                         LDPAA_ETH_RX_BUFFER_SIZE);
 254
 255         ldpaa_fd_set_addr(&fd, (u64)buffer_start);
 256         ldpaa_fd_set_offset(&fd, (uint16_t)(data_offset));
 257         ldpaa_fd_set_bpid(&fd, dflt_dpbp->dpbp_attr.bpid);
 258         ldpaa_fd_set_len(&fd, len);
 259
 260         fd.simple.ctrl = LDPAA_FD_CTRL_ASAL | LDPAA_FD_CTRL_PTA |
 261                                 LDPAA_FD_CTRL_PTV1;
 262
 263         qbman_eq_desc_clear(&ed);
 264         qbman_eq_desc_set_no_orp(&ed, 0);
 265         qbman_eq_desc_set_qd(&ed, priv->tx_qdid, priv->tx_flow_id, 0);
 266
 267         time_start = get_timer(0);
 268
 269         while (get_timer(time_start) < timeo) {
 270                 err = qbman_swp_enqueue(swp, &ed,
 271                                 (const struct qbman_fd *)(&fd));
 272                 if (err != -EBUSY)
 273                         break;
 274         }
 275
 276         if (err < 0) {
 277                 printf("error enqueueing Tx frame\n");
 278                 goto error;
 279         }
 280
 281         return err;
 282
 283 error:
 284         qbman_release_desc_clear(&releasedesc);
 285         qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid);
 286         time_start = get_timer(0);
 287         do {
 288                 /* Release buffer into the QBMAN */
 289                 err = qbman_swp_release(swp, &releasedesc, &buffer_start, 1);
 290         } while (get_timer(time_start) < timeo && err == -EBUSY);
 291
 292         if (err == -EBUSY)
 293                 printf("TX data: QBMAN buffer release fails\n");
 294
 295         return err;
 296 }
 297
 298 static int ldpaa_eth_open(struct eth_device *net_dev, bd_t *bd)
 299 {
 300         struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
 301         struct dpni_queue_attr rx_queue_attr;
 302         struct dpmac_link_state dpmac_link_state = { 0 };
 303 #ifdef DEBUG
 304         struct dpni_link_state link_state;
 305 #endif
 306         int err;
 307
 308         if (net_dev->state == ETH_STATE_ACTIVE)
 309                 return 0;
 310
 311         if (get_mc_boot_status() != 0) {
 312                 printf("ERROR (MC is not booted)\n");
 313                 return -ENODEV;
 314         }
 315
 316         if (get_dpl_apply_status() == 0) {
 317                 printf("ERROR (DPL is deployed. No device available)\n");
 318                 return -ENODEV;
 319         }
 320         /* DPMAC initialization */
 321         err = ldpaa_dpmac_setup(priv);
 322         if (err < 0)
 323                 goto err_dpmac_setup;
 324
 325         /* DPMAC binding DPNI */
 326         err = ldpaa_dpmac_bind(priv);
 327         if (err)
 328                 goto err_dpamc_bind;
 329
 330         /* DPNI initialization */
 331         err = ldpaa_dpni_setup(priv);
 332         if (err < 0)
 333                 goto err_dpni_setup;
 334
 335         err = ldpaa_dpbp_setup();
 336         if (err < 0)
 337                 goto err_dpbp_setup;
 338
 339         /* DPNI binding DPBP */
 340         err = ldpaa_dpni_bind(priv);
 341         if (err)
 342                 goto err_dpni_bind;
 343
 344         err = dpni_add_mac_addr(dflt_mc_io, MC_CMD_NO_FLAGS,
 345                                 dflt_dpni->dpni_handle, net_dev->enetaddr);
 346         if (err) {
 347                 printf("dpni_add_mac_addr() failed\n");
 348                 return err;
 349         }
 350
 351 #ifdef CONFIG_PHYLIB
 352         /* TODO Check this path */
 353         err = phy_startup(priv->phydev);
 354         if (err) {
 355                 printf("%s: Could not initialize\n", priv->phydev->dev->name);
 356                 return err;
 357         }
 358 #else
 359         priv->phydev->speed = SPEED_1000;
 360         priv->phydev->link = 1;
 361         priv->phydev->duplex = DUPLEX_FULL;
 362 #endif
 363
 364         err = dpni_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
 365         if (err < 0) {
 366                 printf("dpni_enable() failed\n");
 367                 return err;
 368         }
 369
 370         dpmac_link_state.rate = SPEED_1000;
 371         dpmac_link_state.options = DPMAC_LINK_OPT_AUTONEG;
 372         dpmac_link_state.up = 1;
 373         err = dpmac_set_link_state(dflt_mc_io, MC_CMD_NO_FLAGS,
 374                                   priv->dpmac_handle, &dpmac_link_state);
 375         if (err < 0) {
 376                 printf("dpmac_set_link_state() failed\n");
 377                 return err;
 378         }
 379
 380 #ifdef DEBUG
 381         err = dpni_get_link_state(dflt_mc_io, MC_CMD_NO_FLAGS,
 382                                   dflt_dpni->dpni_handle, &link_state);
 383         if (err < 0) {
 384                 printf("dpni_get_link_state() failed\n");
 385                 return err;
 386         }
 387
 388         printf("link status: %d - ", link_state.up);
 389         link_state.up == 0 ? printf("down\n") :
 390         link_state.up == 1 ? printf("up\n") : printf("error state\n");
 391 #endif
 392
 393         /* TODO: support multiple Rx flows */
 394         err = dpni_get_rx_flow(dflt_mc_io, MC_CMD_NO_FLAGS,
 395                                dflt_dpni->dpni_handle, 0, 0, &rx_queue_attr);
 396         if (err) {
 397                 printf("dpni_get_rx_flow() failed\n");
 398                 goto err_rx_flow;
 399         }
 400
 401         priv->rx_dflt_fqid = rx_queue_attr.fqid;
 402
 403         err = dpni_get_qdid(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle,
 404                             &priv->tx_qdid);
 405         if (err) {
 406                 printf("dpni_get_qdid() failed\n");
 407                 goto err_qdid;
 408         }
 409
 410         if (!priv->phydev->link)
 411                 printf("%s: No link.\n", priv->phydev->dev->name);
 412
 413         return priv->phydev->link ? 0 : -1;
 414
 415 err_qdid:
 416 err_rx_flow:
 417         dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
 418 err_dpni_bind:
 419         ldpaa_dpbp_free();
 420 err_dpbp_setup:
 421 err_dpamc_bind:
 422         dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
 423 err_dpni_setup:
 424 err_dpmac_setup:
 425         return err;
 426 }
 427
 428 static void ldpaa_eth_stop(struct eth_device *net_dev)
 429 {
 430         struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
 431         int err = 0;
 432
 433         if ((net_dev->state == ETH_STATE_PASSIVE) ||
 434             (net_dev->state == ETH_STATE_INIT))
 435                 return;
 436
 437 #ifdef DEBUG
 438         ldpaa_eth_get_dpni_counter();
 439 #endif
 440
 441         err = dprc_disconnect(dflt_mc_io, MC_CMD_NO_FLAGS,
 442                               dflt_dprc_handle, &dpmac_endpoint);
 443         if (err < 0)
 444                 printf("dprc_disconnect() failed dpmac_endpoint\n");
 445
 446         err = dpmac_destroy(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
 447         if (err < 0)
 448                 printf("dpmac_destroy() failed\n");
 449
 450         /* Stop Tx and Rx traffic */
 451         err = dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
 452         if (err < 0)
 453                 printf("dpni_disable() failed\n");
 454
 455 #ifdef CONFIG_PHYLIB
 456         phy_shutdown(priv->phydev);
 457 #endif
 458
 459         ldpaa_dpbp_free();
 460         dpni_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
 461         dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
 462 }
 463
 464 static void ldpaa_dpbp_drain_cnt(int count)
 465 {
 466         uint64_t buf_array[7];
 467         void *addr;
 468         int ret, i;
 469
 470         BUG_ON(count > 7);
 471
 472         do {
 473                 ret = qbman_swp_acquire(dflt_dpio->sw_portal,
 474                                         dflt_dpbp->dpbp_attr.bpid,
 475                                         buf_array, count);
 476                 if (ret < 0) {
 477                         printf("qbman_swp_acquire() failed\n");
 478                         return;
 479                 }
 480                 for (i = 0; i < ret; i++) {
 481                         addr = (void *)buf_array[i];
 482                         debug("Free: buffer addr =0x%p\n", addr);
 483                         free(addr);
 484                 }
 485         } while (ret);
 486 }
 487
 488 static void ldpaa_dpbp_drain(void)
 489 {
 490         int i;
 491         for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7)
 492                 ldpaa_dpbp_drain_cnt(7);
 493 }
 494
 495 static int ldpaa_bp_add_7(uint16_t bpid)
 496 {
 497         uint64_t buf_array[7];
 498         u8 *addr;
 499         int i;
 500         struct qbman_release_desc rd;
 501
 502         for (i = 0; i < 7; i++) {
 503                 addr = memalign(LDPAA_ETH_BUF_ALIGN, LDPAA_ETH_RX_BUFFER_SIZE);
 504                 if (!addr) {
 505                         printf("addr allocation failed\n");
 506                         goto err_alloc;
 507                 }
 508                 memset(addr, 0x00, LDPAA_ETH_RX_BUFFER_SIZE);
 509                 flush_dcache_range((u64)addr,
 510                                    (u64)(addr + LDPAA_ETH_RX_BUFFER_SIZE));
 511
 512                 buf_array[i] = (uint64_t)addr;
 513                 debug("Release: buffer addr =0x%p\n", addr);
 514         }
 515
 516 release_bufs:
 517         /* In case the portal is busy, retry until successful.
 518          * This function is guaranteed to succeed in a reasonable amount
 519          * of time.
 520          */
 521
 522         do {
 523                 mdelay(1);
 524                 qbman_release_desc_clear(&rd);
 525                 qbman_release_desc_set_bpid(&rd, bpid);
 526         } while (qbman_swp_release(dflt_dpio->sw_portal, &rd, buf_array, i));
 527
 528         return i;
 529
 530 err_alloc:
 531         if (i)
 532                 goto release_bufs;
 533
 534         return 0;
 535 }
 536
 537 static int ldpaa_dpbp_seed(uint16_t bpid)
 538 {
 539         int i;
 540         int count;
 541
 542         for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7) {
 543                 count = ldpaa_bp_add_7(bpid);
 544                 if (count < 7)
 545                         printf("Buffer Seed= %d\n", count);
 546         }
 547
 548         return 0;
 549 }
 550
 551 static int ldpaa_dpbp_setup(void)
 552 {
 553         int err;
 554
 555         err = dpbp_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_attr.id,
 556                         &dflt_dpbp->dpbp_handle);
 557         if (err) {
 558                 printf("dpbp_open() failed\n");
 559                 goto err_open;
 560         }
 561
 562         err = dpbp_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
 563         if (err) {
 564                 printf("dpbp_enable() failed\n");
 565                 goto err_enable;
 566         }
 567
 568         err = dpbp_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
 569                                   dflt_dpbp->dpbp_handle,
 570                                   &dflt_dpbp->dpbp_attr);
 571         if (err) {
 572                 printf("dpbp_get_attributes() failed\n");
 573                 goto err_get_attr;
 574         }
 575
 576         err = ldpaa_dpbp_seed(dflt_dpbp->dpbp_attr.bpid);
 577         if (err) {
 578                 printf("Buffer seeding failed for DPBP %d (bpid=%d)\n",
 579                        dflt_dpbp->dpbp_attr.id, dflt_dpbp->dpbp_attr.bpid);
 580                 goto err_seed;
 581         }
 582
 583         return 0;
 584
 585 err_seed:
 586 err_get_attr:
 587         dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
 588 err_enable:
 589         dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
 590 err_open:
 591         return err;
 592 }
 593
 594 static void ldpaa_dpbp_free(void)
 595 {
 596         ldpaa_dpbp_drain();
 597         dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
 598         dpbp_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
 599         dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
 600 }
 601
 602 static int ldpaa_dpmac_setup(struct ldpaa_eth_priv *priv)
 603 {
 604         int err = 0;
 605         struct dpmac_cfg dpmac_cfg;
 606
 607         dpmac_cfg.mac_id = priv->dpmac_id;
 608         err = dpmac_create(dflt_mc_io, MC_CMD_NO_FLAGS, &dpmac_cfg,
 609                           &priv->dpmac_handle);
 610         if (err)
 611                 printf("dpmac_create() failed\n");
 612         return err;
 613 }
 614
 615 static int ldpaa_dpmac_bind(struct ldpaa_eth_priv *priv)
 616 {
 617         int err = 0;
 618         struct dprc_connection_cfg dprc_connection_cfg = {
 619                 /* If both rates are zero the connection */
 620                 /* will be configured in "best effort" mode. */
 621                 .committed_rate = 0,
 622                 .max_rate = 0
 623         };
 624
 625 #ifdef DEBUG
 626         struct dprc_endpoint dbg_endpoint;
 627         int state = 0;
 628 #endif
 629
 630         memset(&dpmac_endpoint, 0, sizeof(struct dprc_endpoint));
 631         strcpy(dpmac_endpoint.type, "dpmac");
 632         dpmac_endpoint.id = priv->dpmac_id;
 633
 634         memset(&dpni_endpoint, 0, sizeof(struct dprc_endpoint));
 635         strcpy(dpni_endpoint.type, "dpni");
 636         dpni_endpoint.id = dflt_dpni->dpni_id;
 637
 638         err = dprc_connect(dflt_mc_io, MC_CMD_NO_FLAGS,
 639                              dflt_dprc_handle,
 640                              &dpmac_endpoint,
 641                              &dpni_endpoint,
 642                              &dprc_connection_cfg);
 643         if (err)
 644                 printf("dprc_connect() failed\n");
 645
 646 #ifdef DEBUG
 647         err = dprc_get_connection(dflt_mc_io, MC_CMD_NO_FLAGS,
 648                                     dflt_dprc_handle, &dpni_endpoint,
 649                                     &dbg_endpoint, &state);
 650         printf("%s, DPMAC Type= %s\n", __func__, dbg_endpoint.type);
 651         printf("%s, DPMAC ID= %d\n", __func__, dbg_endpoint.id);
 652         printf("%s, DPMAC State= %d\n", __func__, state);
 653
 654         memset(&dbg_endpoint, 0, sizeof(struct dprc_endpoint));
 655         err = dprc_get_connection(dflt_mc_io, MC_CMD_NO_FLAGS,
 656                                     dflt_dprc_handle, &dpmac_endpoint,
 657                                     &dbg_endpoint, &state);
 658         printf("%s, DPNI Type= %s\n", __func__, dbg_endpoint.type);
 659         printf("%s, DPNI ID= %d\n", __func__, dbg_endpoint.id);
 660         printf("%s, DPNI State= %d\n", __func__, state);
 661 #endif
 662         return err;
 663 }
 664
 665 static int ldpaa_dpni_setup(struct ldpaa_eth_priv *priv)
 666 {
 667         int err;
 668
 669         /* and get a handle for the DPNI this interface is associate with */
 670         err = dpni_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_id,
 671                         &dflt_dpni->dpni_handle);
 672         if (err) {
 673                 printf("dpni_open() failed\n");
 674                 goto err_open;
 675         }
 676
 677         err = dpni_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
 678                                   dflt_dpni->dpni_handle,
 679                                   &dflt_dpni->dpni_attrs);
 680         if (err) {
 681                 printf("dpni_get_attributes() failed (err=%d)\n", err);
 682                 goto err_get_attr;
 683         }
 684
 685         /* Configure our buffers' layout */
 686         dflt_dpni->buf_layout.options = DPNI_BUF_LAYOUT_OPT_PARSER_RESULT |
 687                                    DPNI_BUF_LAYOUT_OPT_FRAME_STATUS |
 688                                    DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE |
 689                                    DPNI_BUF_LAYOUT_OPT_DATA_ALIGN;
 690         dflt_dpni->buf_layout.pass_parser_result = true;
 691         dflt_dpni->buf_layout.pass_frame_status = true;
 692         dflt_dpni->buf_layout.private_data_size = LDPAA_ETH_SWA_SIZE;
 693         /* HW erratum mandates data alignment in multiples of 256 */
 694         dflt_dpni->buf_layout.data_align = LDPAA_ETH_BUF_ALIGN;
 695         /* ...rx, ... */
 696         err = dpni_set_rx_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
 697                                         dflt_dpni->dpni_handle,
 698                                         &dflt_dpni->buf_layout);
 699         if (err) {
 700                 printf("dpni_set_rx_buffer_layout() failed");
 701                 goto err_buf_layout;
 702         }
 703
 704         /* ... tx, ... */
 705         /* remove Rx-only options */
 706         dflt_dpni->buf_layout.options &= ~(DPNI_BUF_LAYOUT_OPT_DATA_ALIGN |
 707                                       DPNI_BUF_LAYOUT_OPT_PARSER_RESULT);
 708         err = dpni_set_tx_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
 709                                         dflt_dpni->dpni_handle,
 710                                         &dflt_dpni->buf_layout);
 711         if (err) {
 712                 printf("dpni_set_tx_buffer_layout() failed");
 713                 goto err_buf_layout;
 714         }
 715
 716         /* ... tx-confirm. */
 717         dflt_dpni->buf_layout.options &= ~DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE;
 718         err = dpni_set_tx_conf_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
 719                                              dflt_dpni->dpni_handle,
 720                                              &dflt_dpni->buf_layout);
 721         if (err) {
 722                 printf("dpni_set_tx_conf_buffer_layout() failed");
 723                 goto err_buf_layout;
 724         }
 725
 726         /* Now that we've set our tx buffer layout, retrieve the minimum
 727          * required tx data offset.
 728          */
 729         err = dpni_get_tx_data_offset(dflt_mc_io, MC_CMD_NO_FLAGS,
 730                                       dflt_dpni->dpni_handle,
 731                                       &priv->tx_data_offset);
 732         if (err) {
 733                 printf("dpni_get_tx_data_offset() failed\n");
 734                 goto err_data_offset;
 735         }
 736
 737         /* Warn in case TX data offset is not multiple of 64 bytes. */
 738         WARN_ON(priv->tx_data_offset % 64);
 739
 740         /* Accomodate SWA space. */
 741         priv->tx_data_offset += LDPAA_ETH_SWA_SIZE;
 742         debug("priv->tx_data_offset=%d\n", priv->tx_data_offset);
 743
 744         return 0;
 745
 746 err_data_offset:
 747 err_buf_layout:
 748 err_get_attr:
 749         dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
 750 err_open:
 751         return err;
 752 }
 753
 754 static int ldpaa_dpni_bind(struct ldpaa_eth_priv *priv)
 755 {
 756         struct dpni_pools_cfg pools_params;
 757         struct dpni_tx_flow_cfg dflt_tx_flow;
 758         int err = 0;
 759
 760         pools_params.num_dpbp = 1;
 761         pools_params.pools[0].dpbp_id = (uint16_t)dflt_dpbp->dpbp_attr.id;
 762         pools_params.pools[0].buffer_size = LDPAA_ETH_RX_BUFFER_SIZE;
 763         err = dpni_set_pools(dflt_mc_io, MC_CMD_NO_FLAGS,
 764                              dflt_dpni->dpni_handle, &pools_params);
 765         if (err) {
 766                 printf("dpni_set_pools() failed\n");
 767                 return err;
 768         }
 769
 770         priv->tx_flow_id = DPNI_NEW_FLOW_ID;
 771         memset(&dflt_tx_flow, 0, sizeof(dflt_tx_flow));
 772
 773         dflt_tx_flow.options = DPNI_TX_FLOW_OPT_ONLY_TX_ERROR;
 774         dflt_tx_flow.conf_err_cfg.use_default_queue = 0;
 775         dflt_tx_flow.conf_err_cfg.errors_only = 1;
 776         err = dpni_set_tx_flow(dflt_mc_io, MC_CMD_NO_FLAGS,
 777                                dflt_dpni->dpni_handle, &priv->tx_flow_id,
 778                                &dflt_tx_flow);
 779         if (err) {
 780                 printf("dpni_set_tx_flow() failed\n");
 781                 return err;
 782         }
 783
 784         return 0;
 785 }
 786
 787 static int ldpaa_eth_netdev_init(struct eth_device *net_dev,
 788                                  phy_interface_t enet_if)
 789 {
 790         int err;
 791         struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
 792
 793         sprintf(net_dev->name, "DPMAC%d@%s", priv->dpmac_id,
 794                 phy_interface_strings[enet_if]);
 795
 796         net_dev->iobase = 0;
 797         net_dev->init = ldpaa_eth_open;
 798         net_dev->halt = ldpaa_eth_stop;
 799         net_dev->send = ldpaa_eth_tx;
 800         net_dev->recv = ldpaa_eth_pull_dequeue_rx;
 801 /*
 802         TODO: PHY MDIO information
 803         priv->bus = info->bus;
 804         priv->phyaddr = info->phy_addr;
 805         priv->enet_if = info->enet_if;
 806 */
 807
 808         if (init_phy(net_dev))
 809                 return 0;
 810
 811         err = eth_register(net_dev);
 812         if (err < 0) {
 813                 printf("eth_register() = %d\n", err);
 814                 return err;
 815         }
 816
 817         return 0;
 818 }
 819
 820 int ldpaa_eth_init(int dpmac_id, phy_interface_t enet_if)
 821 {
 822         struct eth_device               *net_dev = NULL;
 823         struct ldpaa_eth_priv           *priv = NULL;
 824         int                             err = 0;
 825
 826
 827         /* Net device */
 828         net_dev = (struct eth_device *)malloc(sizeof(struct eth_device));
 829         if (!net_dev) {
 830                 printf("eth_device malloc() failed\n");
 831                 return -ENOMEM;
 832         }
 833         memset(net_dev, 0, sizeof(struct eth_device));
 834
 835         /* alloc the ldpaa ethernet private struct */
 836         priv = (struct ldpaa_eth_priv *)malloc(sizeof(struct ldpaa_eth_priv));
 837         if (!priv) {
 838                 printf("ldpaa_eth_priv malloc() failed\n");
 839                 return -ENOMEM;
 840         }
 841         memset(priv, 0, sizeof(struct ldpaa_eth_priv));
 842
 843         net_dev->priv = (void *)priv;
 844         priv->net_dev = (struct eth_device *)net_dev;
 845         priv->dpmac_id = dpmac_id;
 846         debug("%s dpmac_id=%d\n", __func__, dpmac_id);
 847
 848         err = ldpaa_eth_netdev_init(net_dev, enet_if);
 849         if (err)
 850                 goto err_netdev_init;
 851
 852         debug("ldpaa ethernet: Probed interface %s\n", net_dev->name);
 853         return 0;
 854
 855 err_netdev_init:
 856         free(priv);
 857         net_dev->priv = NULL;
 858         free(net_dev);
 859
 860         return err;
 861 }