2 * Copyright (C) 2014 Freescale Semiconductor
4 * SPDX-License-Identifier: GPL-2.0+
14 #include <linux/compat.h>
15 #include <fsl-mc/fsl_dpmac.h>
17 #include <fsl-mc/ldpaa_wriop.h>
18 #include "ldpaa_eth.h"
21 static int init_phy(struct eth_device *dev)
23 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)dev->priv;
24 struct phy_device *phydev = NULL;
27 bus = wriop_get_mdio(priv->dpmac_id);
31 phydev = phy_connect(bus, wriop_get_phy_address(priv->dpmac_id),
32 dev, wriop_get_enet_if(priv->dpmac_id));
34 printf("Failed to connect\n");
38 priv->phydev = phydev;
40 return phy_config(phydev);
45 static void ldpaa_eth_get_dpni_counter(void)
50 err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
51 dflt_dpni->dpni_handle,
55 printf("dpni_get_counter: DPNI_CNT_ING_FRAME failed\n");
58 printf("DPNI_CNT_ING_FRAME=%lld\n", value);
60 err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
61 dflt_dpni->dpni_handle,
65 printf("dpni_get_counter: DPNI_CNT_ING_BYTE failed\n");
68 printf("DPNI_CNT_ING_BYTE=%lld\n", value);
70 err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
71 dflt_dpni->dpni_handle,
72 DPNI_CNT_ING_FRAME_DROP ,
75 printf("dpni_get_counter: DPNI_CNT_ING_FRAME_DROP failed\n");
78 printf("DPNI_CNT_ING_FRAME_DROP =%lld\n", value);
80 err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
81 dflt_dpni->dpni_handle,
82 DPNI_CNT_ING_FRAME_DISCARD,
85 printf("dpni_get_counter: DPNI_CNT_ING_FRAME_DISCARD failed\n");
88 printf("DPNI_CNT_ING_FRAME_DISCARD=%lld\n", value);
90 err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
91 dflt_dpni->dpni_handle,
95 printf("dpni_get_counter: DPNI_CNT_EGR_FRAME failed\n");
98 printf("DPNI_CNT_EGR_FRAME=%lld\n", value);
100 err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
101 dflt_dpni->dpni_handle,
105 printf("dpni_get_counter: DPNI_CNT_EGR_BYTE failed\n");
108 printf("DPNI_CNT_EGR_BYTE =%lld\n", value);
110 err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
111 dflt_dpni->dpni_handle,
112 DPNI_CNT_EGR_FRAME_DISCARD ,
115 printf("dpni_get_counter: DPNI_CNT_EGR_FRAME_DISCARD failed\n");
118 printf("DPNI_CNT_EGR_FRAME_DISCARD =%lld\n", value);
121 static void ldpaa_eth_get_dpmac_counter(struct eth_device *net_dev)
123 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
127 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
132 printf("dpmac_get_counter: DPMAC_CNT_ING_BYTE failed\n");
135 printf("DPMAC_CNT_ING_BYTE=%lld\n", value);
137 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
139 DPMAC_CNT_ING_FRAME_DISCARD,
142 printf("dpmac_get_counter: DPMAC_CNT_ING_FRAME_DISCARD failed\n");
145 printf("DPMAC_CNT_ING_FRAME_DISCARD=%lld\n", value);
147 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
149 DPMAC_CNT_ING_ALIGN_ERR,
152 printf("dpmac_get_counter: DPMAC_CNT_ING_ALIGN_ERR failed\n");
155 printf("DPMAC_CNT_ING_ALIGN_ERR =%lld\n", value);
157 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
162 printf("dpmac_get_counter: DPMAC_CNT_ING_BYTE failed\n");
165 printf("DPMAC_CNT_ING_BYTE=%lld\n", value);
167 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
169 DPMAC_CNT_ING_ERR_FRAME,
172 printf("dpmac_get_counter: DPMAC_CNT_ING_ERR_FRAME failed\n");
175 printf("DPMAC_CNT_ING_ERR_FRAME=%lld\n", value);
177 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
182 printf("dpmac_get_counter: DPMAC_CNT_EGR_BYTE failed\n");
185 printf("DPMAC_CNT_EGR_BYTE =%lld\n", value);
187 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
189 DPMAC_CNT_EGR_ERR_FRAME ,
192 printf("dpmac_get_counter: DPMAC_CNT_EGR_ERR_FRAME failed\n");
195 printf("DPMAC_CNT_EGR_ERR_FRAME =%lld\n", value);
199 static void ldpaa_eth_rx(struct ldpaa_eth_priv *priv,
200 const struct dpaa_fd *fd)
205 struct ldpaa_fas *fas;
206 uint32_t status, err;
207 u32 timeo = (CONFIG_SYS_HZ * 2) / 1000;
209 struct qbman_release_desc releasedesc;
210 struct qbman_swp *swp = dflt_dpio->sw_portal;
212 fd_addr = ldpaa_fd_get_addr(fd);
213 fd_offset = ldpaa_fd_get_offset(fd);
214 fd_length = ldpaa_fd_get_len(fd);
216 debug("Rx frame:data addr=0x%p size=0x%x\n", (u64 *)fd_addr, fd_length);
218 if (fd->simple.frc & LDPAA_FD_FRC_FASV) {
219 /* Read the frame annotation status word and check for errors */
220 fas = (struct ldpaa_fas *)
221 ((uint8_t *)(fd_addr) +
222 dflt_dpni->buf_layout.private_data_size);
223 status = le32_to_cpu(fas->status);
224 if (status & LDPAA_ETH_RX_ERR_MASK) {
225 printf("Rx frame error(s): 0x%08x\n",
226 status & LDPAA_ETH_RX_ERR_MASK);
228 } else if (status & LDPAA_ETH_RX_UNSUPP_MASK) {
229 printf("Unsupported feature in bitmask: 0x%08x\n",
230 status & LDPAA_ETH_RX_UNSUPP_MASK);
235 debug("Rx frame: To Upper layer\n");
236 net_process_received_packet((uint8_t *)(fd_addr) + fd_offset,
240 flush_dcache_range(fd_addr, fd_addr + LDPAA_ETH_RX_BUFFER_SIZE);
241 qbman_release_desc_clear(&releasedesc);
242 qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid);
243 time_start = get_timer(0);
245 /* Release buffer into the QBMAN */
246 err = qbman_swp_release(swp, &releasedesc, &fd_addr, 1);
247 } while (get_timer(time_start) < timeo && err == -EBUSY);
250 printf("Rx frame: QBMAN buffer release fails\n");
255 static int ldpaa_eth_pull_dequeue_rx(struct eth_device *dev)
257 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)dev->priv;
258 const struct ldpaa_dq *dq;
259 const struct dpaa_fd *fd;
260 int i = 5, err = 0, status;
261 u32 timeo = (CONFIG_SYS_HZ * 2) / 1000;
263 static struct qbman_pull_desc pulldesc;
264 struct qbman_swp *swp = dflt_dpio->sw_portal;
267 qbman_pull_desc_clear(&pulldesc);
268 qbman_pull_desc_set_numframes(&pulldesc, 1);
269 qbman_pull_desc_set_fq(&pulldesc, priv->rx_dflt_fqid);
271 err = qbman_swp_pull(swp, &pulldesc);
273 printf("Dequeue frames error:0x%08x\n", err);
277 time_start = get_timer(0);
280 dq = qbman_swp_dqrr_next(swp);
281 } while (get_timer(time_start) < timeo && !dq);
284 /* Check for valid frame. If not sent a consume
285 * confirmation to QBMAN otherwise give it to NADK
286 * application and then send consume confirmation to
289 status = (uint8_t)ldpaa_dq_flags(dq);
290 if ((status & LDPAA_DQ_STAT_VALIDFRAME) == 0) {
291 debug("Dequeue RX frames:");
292 debug("No frame delivered\n");
294 qbman_swp_dqrr_consume(swp, dq);
298 fd = ldpaa_dq_fd(dq);
300 /* Obtain FD and process it */
301 ldpaa_eth_rx(priv, fd);
302 qbman_swp_dqrr_consume(swp, dq);
306 debug("No DQRR entries\n");
314 static int ldpaa_eth_tx(struct eth_device *net_dev, void *buf, int len)
316 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
319 int data_offset, err;
320 u32 timeo = (CONFIG_SYS_HZ * 10) / 1000;
322 struct qbman_swp *swp = dflt_dpio->sw_portal;
323 struct qbman_eq_desc ed;
324 struct qbman_release_desc releasedesc;
326 /* Setup the FD fields */
327 memset(&fd, 0, sizeof(fd));
329 data_offset = priv->tx_data_offset;
332 err = qbman_swp_acquire(dflt_dpio->sw_portal,
333 dflt_dpbp->dpbp_attr.bpid,
335 } while (err == -EBUSY);
338 printf("qbman_swp_acquire() failed\n");
342 debug("TX data: malloc buffer start=0x%p\n", (u64 *)buffer_start);
344 memcpy(((uint8_t *)(buffer_start) + data_offset), buf, len);
346 flush_dcache_range(buffer_start, buffer_start +
347 LDPAA_ETH_RX_BUFFER_SIZE);
349 ldpaa_fd_set_addr(&fd, (u64)buffer_start);
350 ldpaa_fd_set_offset(&fd, (uint16_t)(data_offset));
351 ldpaa_fd_set_bpid(&fd, dflt_dpbp->dpbp_attr.bpid);
352 ldpaa_fd_set_len(&fd, len);
354 fd.simple.ctrl = LDPAA_FD_CTRL_ASAL | LDPAA_FD_CTRL_PTA |
357 qbman_eq_desc_clear(&ed);
358 qbman_eq_desc_set_no_orp(&ed, 0);
359 qbman_eq_desc_set_qd(&ed, priv->tx_qdid, priv->tx_flow_id, 0);
361 time_start = get_timer(0);
363 while (get_timer(time_start) < timeo) {
364 err = qbman_swp_enqueue(swp, &ed,
365 (const struct qbman_fd *)(&fd));
371 printf("error enqueueing Tx frame\n");
378 qbman_release_desc_clear(&releasedesc);
379 qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid);
380 time_start = get_timer(0);
382 /* Release buffer into the QBMAN */
383 err = qbman_swp_release(swp, &releasedesc, &buffer_start, 1);
384 } while (get_timer(time_start) < timeo && err == -EBUSY);
387 printf("TX data: QBMAN buffer release fails\n");
392 static int ldpaa_eth_open(struct eth_device *net_dev, bd_t *bd)
394 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
395 struct dpni_queue_attr rx_queue_attr;
396 struct dpmac_link_state dpmac_link_state = { 0 };
398 struct dpni_link_state link_state;
402 phy_interface_t enet_if;
404 if (net_dev->state == ETH_STATE_ACTIVE)
407 if (get_mc_boot_status() != 0) {
408 printf("ERROR (MC is not booted)\n");
412 if (get_dpl_apply_status() == 0) {
413 printf("ERROR (DPL is deployed. No device available)\n");
417 /* DPMAC initialization */
418 err = ldpaa_dpmac_setup(priv);
420 goto err_dpmac_setup;
424 err = phy_startup(priv->phydev);
426 printf("%s: Could not initialize\n",
427 priv->phydev->dev->name);
432 priv->phydev = (struct phy_device *)malloc(sizeof(struct phy_device));
433 memset(priv->phydev, 0, sizeof(struct phy_device));
435 priv->phydev->speed = SPEED_1000;
436 priv->phydev->link = 1;
437 priv->phydev->duplex = DUPLEX_FULL;
440 bus = wriop_get_mdio(priv->dpmac_id);
441 enet_if = wriop_get_enet_if(priv->dpmac_id);
443 (enet_if == PHY_INTERFACE_MODE_XGMII)) {
444 priv->phydev = (struct phy_device *)
445 malloc(sizeof(struct phy_device));
446 memset(priv->phydev, 0, sizeof(struct phy_device));
448 priv->phydev->speed = SPEED_10000;
449 priv->phydev->link = 1;
450 priv->phydev->duplex = DUPLEX_FULL;
453 if (!priv->phydev->link) {
454 printf("%s: No link.\n", priv->phydev->dev->name);
459 /* DPMAC binding DPNI */
460 err = ldpaa_dpmac_bind(priv);
464 /* DPNI initialization */
465 err = ldpaa_dpni_setup(priv);
469 err = ldpaa_dpbp_setup();
473 /* DPNI binding DPBP */
474 err = ldpaa_dpni_bind(priv);
478 err = dpni_add_mac_addr(dflt_mc_io, MC_CMD_NO_FLAGS,
479 dflt_dpni->dpni_handle, net_dev->enetaddr);
481 printf("dpni_add_mac_addr() failed\n");
485 err = dpni_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
487 printf("dpni_enable() failed\n");
491 dpmac_link_state.rate = priv->phydev->speed;
493 if (priv->phydev->autoneg == AUTONEG_DISABLE)
494 dpmac_link_state.options &= ~DPMAC_LINK_OPT_AUTONEG;
496 dpmac_link_state.options |= DPMAC_LINK_OPT_AUTONEG;
498 if (priv->phydev->duplex == DUPLEX_HALF)
499 dpmac_link_state.options |= DPMAC_LINK_OPT_HALF_DUPLEX;
501 dpmac_link_state.up = priv->phydev->link;
503 err = dpmac_set_link_state(dflt_mc_io, MC_CMD_NO_FLAGS,
504 priv->dpmac_handle, &dpmac_link_state);
506 printf("dpmac_set_link_state() failed\n");
511 err = dpni_get_link_state(dflt_mc_io, MC_CMD_NO_FLAGS,
512 dflt_dpni->dpni_handle, &link_state);
514 printf("dpni_get_link_state() failed\n");
518 printf("link status: %d - ", link_state.up);
519 link_state.up == 0 ? printf("down\n") :
520 link_state.up == 1 ? printf("up\n") : printf("error state\n");
523 /* TODO: support multiple Rx flows */
524 err = dpni_get_rx_flow(dflt_mc_io, MC_CMD_NO_FLAGS,
525 dflt_dpni->dpni_handle, 0, 0, &rx_queue_attr);
527 printf("dpni_get_rx_flow() failed\n");
531 priv->rx_dflt_fqid = rx_queue_attr.fqid;
533 err = dpni_get_qdid(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle,
536 printf("dpni_get_qdid() failed\n");
540 return priv->phydev->link;
544 dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
548 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
551 dpmac_destroy(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
556 static void ldpaa_eth_stop(struct eth_device *net_dev)
558 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
561 struct mii_dev *bus = wriop_get_mdio(priv->dpmac_id);
564 if ((net_dev->state == ETH_STATE_PASSIVE) ||
565 (net_dev->state == ETH_STATE_INIT))
569 ldpaa_eth_get_dpni_counter();
570 ldpaa_eth_get_dpmac_counter(net_dev);
573 err = dprc_disconnect(dflt_mc_io, MC_CMD_NO_FLAGS,
574 dflt_dprc_handle, &dpmac_endpoint);
576 printf("dprc_disconnect() failed dpmac_endpoint\n");
578 err = dpmac_destroy(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
580 printf("dpmac_destroy() failed\n");
582 /* Stop Tx and Rx traffic */
583 err = dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
585 printf("dpni_disable() failed\n");
588 if (priv->phydev && bus != NULL)
589 phy_shutdown(priv->phydev);
595 dpni_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
596 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
599 static void ldpaa_dpbp_drain_cnt(int count)
601 uint64_t buf_array[7];
608 ret = qbman_swp_acquire(dflt_dpio->sw_portal,
609 dflt_dpbp->dpbp_attr.bpid,
612 printf("qbman_swp_acquire() failed\n");
615 for (i = 0; i < ret; i++) {
616 addr = (void *)buf_array[i];
617 debug("Free: buffer addr =0x%p\n", addr);
623 static void ldpaa_dpbp_drain(void)
626 for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7)
627 ldpaa_dpbp_drain_cnt(7);
630 static int ldpaa_bp_add_7(uint16_t bpid)
632 uint64_t buf_array[7];
635 struct qbman_release_desc rd;
637 for (i = 0; i < 7; i++) {
638 addr = memalign(LDPAA_ETH_BUF_ALIGN, LDPAA_ETH_RX_BUFFER_SIZE);
640 printf("addr allocation failed\n");
643 memset(addr, 0x00, LDPAA_ETH_RX_BUFFER_SIZE);
644 flush_dcache_range((u64)addr,
645 (u64)(addr + LDPAA_ETH_RX_BUFFER_SIZE));
647 buf_array[i] = (uint64_t)addr;
648 debug("Release: buffer addr =0x%p\n", addr);
652 /* In case the portal is busy, retry until successful.
653 * This function is guaranteed to succeed in a reasonable amount
659 qbman_release_desc_clear(&rd);
660 qbman_release_desc_set_bpid(&rd, bpid);
661 } while (qbman_swp_release(dflt_dpio->sw_portal, &rd, buf_array, i));
672 static int ldpaa_dpbp_seed(uint16_t bpid)
677 for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7) {
678 count = ldpaa_bp_add_7(bpid);
680 printf("Buffer Seed= %d\n", count);
686 static int ldpaa_dpbp_setup(void)
690 err = dpbp_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_attr.id,
691 &dflt_dpbp->dpbp_handle);
693 printf("dpbp_open() failed\n");
697 err = dpbp_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
699 printf("dpbp_enable() failed\n");
703 err = dpbp_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
704 dflt_dpbp->dpbp_handle,
705 &dflt_dpbp->dpbp_attr);
707 printf("dpbp_get_attributes() failed\n");
711 err = ldpaa_dpbp_seed(dflt_dpbp->dpbp_attr.bpid);
713 printf("Buffer seeding failed for DPBP %d (bpid=%d)\n",
714 dflt_dpbp->dpbp_attr.id, dflt_dpbp->dpbp_attr.bpid);
722 dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
724 dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
729 static void ldpaa_dpbp_free(void)
732 dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
733 dpbp_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
734 dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
737 static int ldpaa_dpmac_version_check(struct fsl_mc_io *mc_io,
738 struct ldpaa_eth_priv *priv)
740 struct dpmac_attr attr;
743 memset(&attr, 0, sizeof(struct dpmac_attr));
744 error = dpmac_get_attributes(mc_io, MC_CMD_NO_FLAGS,
748 if ((attr.version.major != DPMAC_VER_MAJOR) ||
749 (attr.version.minor != DPMAC_VER_MINOR)) {
750 printf("DPMAC version mismatch found %u.%u,",
751 attr.version.major, attr.version.minor);
752 printf("supported version is %u.%u\n",
753 DPMAC_VER_MAJOR, DPMAC_VER_MINOR);
760 static int ldpaa_dpmac_setup(struct ldpaa_eth_priv *priv)
763 struct dpmac_cfg dpmac_cfg;
765 dpmac_cfg.mac_id = priv->dpmac_id;
766 err = dpmac_create(dflt_mc_io, MC_CMD_NO_FLAGS, &dpmac_cfg,
767 &priv->dpmac_handle);
769 printf("dpmac_create() failed\n");
771 err = ldpaa_dpmac_version_check(dflt_mc_io, priv);
773 printf("ldpaa_dpmac_version_check() failed: %d\n", err);
778 static int ldpaa_dpmac_bind(struct ldpaa_eth_priv *priv)
781 struct dprc_connection_cfg dprc_connection_cfg = {
782 /* If both rates are zero the connection */
783 /* will be configured in "best effort" mode. */
789 struct dprc_endpoint dbg_endpoint;
793 memset(&dpmac_endpoint, 0, sizeof(struct dprc_endpoint));
794 strcpy(dpmac_endpoint.type, "dpmac");
795 dpmac_endpoint.id = priv->dpmac_id;
797 memset(&dpni_endpoint, 0, sizeof(struct dprc_endpoint));
798 strcpy(dpni_endpoint.type, "dpni");
799 dpni_endpoint.id = dflt_dpni->dpni_id;
801 err = dprc_connect(dflt_mc_io, MC_CMD_NO_FLAGS,
805 &dprc_connection_cfg);
807 printf("dprc_connect() failed\n");
810 err = dprc_get_connection(dflt_mc_io, MC_CMD_NO_FLAGS,
811 dflt_dprc_handle, &dpni_endpoint,
812 &dbg_endpoint, &state);
813 printf("%s, DPMAC Type= %s\n", __func__, dbg_endpoint.type);
814 printf("%s, DPMAC ID= %d\n", __func__, dbg_endpoint.id);
815 printf("%s, DPMAC State= %d\n", __func__, state);
817 memset(&dbg_endpoint, 0, sizeof(struct dprc_endpoint));
818 err = dprc_get_connection(dflt_mc_io, MC_CMD_NO_FLAGS,
819 dflt_dprc_handle, &dpmac_endpoint,
820 &dbg_endpoint, &state);
821 printf("%s, DPNI Type= %s\n", __func__, dbg_endpoint.type);
822 printf("%s, DPNI ID= %d\n", __func__, dbg_endpoint.id);
823 printf("%s, DPNI State= %d\n", __func__, state);
828 static int ldpaa_dpni_setup(struct ldpaa_eth_priv *priv)
832 /* and get a handle for the DPNI this interface is associate with */
833 err = dpni_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_id,
834 &dflt_dpni->dpni_handle);
836 printf("dpni_open() failed\n");
840 err = dpni_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
841 dflt_dpni->dpni_handle,
842 &dflt_dpni->dpni_attrs);
844 printf("dpni_get_attributes() failed (err=%d)\n", err);
848 /* Configure our buffers' layout */
849 dflt_dpni->buf_layout.options = DPNI_BUF_LAYOUT_OPT_PARSER_RESULT |
850 DPNI_BUF_LAYOUT_OPT_FRAME_STATUS |
851 DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE |
852 DPNI_BUF_LAYOUT_OPT_DATA_ALIGN;
853 dflt_dpni->buf_layout.pass_parser_result = true;
854 dflt_dpni->buf_layout.pass_frame_status = true;
855 dflt_dpni->buf_layout.private_data_size = LDPAA_ETH_SWA_SIZE;
856 /* HW erratum mandates data alignment in multiples of 256 */
857 dflt_dpni->buf_layout.data_align = LDPAA_ETH_BUF_ALIGN;
859 err = dpni_set_rx_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
860 dflt_dpni->dpni_handle,
861 &dflt_dpni->buf_layout);
863 printf("dpni_set_rx_buffer_layout() failed");
868 /* remove Rx-only options */
869 dflt_dpni->buf_layout.options &= ~(DPNI_BUF_LAYOUT_OPT_DATA_ALIGN |
870 DPNI_BUF_LAYOUT_OPT_PARSER_RESULT);
871 err = dpni_set_tx_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
872 dflt_dpni->dpni_handle,
873 &dflt_dpni->buf_layout);
875 printf("dpni_set_tx_buffer_layout() failed");
879 /* ... tx-confirm. */
880 dflt_dpni->buf_layout.options &= ~DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE;
881 err = dpni_set_tx_conf_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
882 dflt_dpni->dpni_handle,
883 &dflt_dpni->buf_layout);
885 printf("dpni_set_tx_conf_buffer_layout() failed");
889 /* Now that we've set our tx buffer layout, retrieve the minimum
890 * required tx data offset.
892 err = dpni_get_tx_data_offset(dflt_mc_io, MC_CMD_NO_FLAGS,
893 dflt_dpni->dpni_handle,
894 &priv->tx_data_offset);
896 printf("dpni_get_tx_data_offset() failed\n");
897 goto err_data_offset;
900 /* Warn in case TX data offset is not multiple of 64 bytes. */
901 WARN_ON(priv->tx_data_offset % 64);
903 /* Accomodate SWA space. */
904 priv->tx_data_offset += LDPAA_ETH_SWA_SIZE;
905 debug("priv->tx_data_offset=%d\n", priv->tx_data_offset);
912 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
917 static int ldpaa_dpni_bind(struct ldpaa_eth_priv *priv)
919 struct dpni_pools_cfg pools_params;
920 struct dpni_tx_flow_cfg dflt_tx_flow;
921 struct dpni_tx_conf_cfg tx_conf_cfg;
924 memset(&pools_params, 0, sizeof(pools_params));
925 pools_params.num_dpbp = 1;
926 pools_params.pools[0].dpbp_id = (uint16_t)dflt_dpbp->dpbp_attr.id;
927 pools_params.pools[0].buffer_size = LDPAA_ETH_RX_BUFFER_SIZE;
928 err = dpni_set_pools(dflt_mc_io, MC_CMD_NO_FLAGS,
929 dflt_dpni->dpni_handle, &pools_params);
931 printf("dpni_set_pools() failed\n");
935 priv->tx_flow_id = DPNI_NEW_FLOW_ID;
936 memset(&dflt_tx_flow, 0, sizeof(dflt_tx_flow));
938 dflt_tx_flow.use_common_tx_conf_queue = 0;
939 err = dpni_set_tx_flow(dflt_mc_io, MC_CMD_NO_FLAGS,
940 dflt_dpni->dpni_handle, &priv->tx_flow_id,
943 printf("dpni_set_tx_flow() failed\n");
947 memset(&tx_conf_cfg, 0, sizeof(struct dpni_tx_conf_cfg));
948 tx_conf_cfg.errors_only = true;
949 /*Set tx-conf and error configuration*/
950 err = dpni_set_tx_conf(dflt_mc_io, MC_CMD_NO_FLAGS,
951 dflt_dpni->dpni_handle,
952 priv->tx_flow_id, &tx_conf_cfg);
954 printf("dpni_set_tx_conf() failed\n");
961 static int ldpaa_eth_netdev_init(struct eth_device *net_dev,
962 phy_interface_t enet_if)
965 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
967 sprintf(net_dev->name, "DPMAC%d@%s", priv->dpmac_id,
968 phy_interface_strings[enet_if]);
971 net_dev->init = ldpaa_eth_open;
972 net_dev->halt = ldpaa_eth_stop;
973 net_dev->send = ldpaa_eth_tx;
974 net_dev->recv = ldpaa_eth_pull_dequeue_rx;
977 err = init_phy(net_dev);
982 err = eth_register(net_dev);
984 printf("eth_register() = %d\n", err);
991 int ldpaa_eth_init(int dpmac_id, phy_interface_t enet_if)
993 struct eth_device *net_dev = NULL;
994 struct ldpaa_eth_priv *priv = NULL;
999 net_dev = (struct eth_device *)malloc(sizeof(struct eth_device));
1001 printf("eth_device malloc() failed\n");
1004 memset(net_dev, 0, sizeof(struct eth_device));
1006 /* alloc the ldpaa ethernet private struct */
1007 priv = (struct ldpaa_eth_priv *)malloc(sizeof(struct ldpaa_eth_priv));
1009 printf("ldpaa_eth_priv malloc() failed\n");
1012 memset(priv, 0, sizeof(struct ldpaa_eth_priv));
1014 net_dev->priv = (void *)priv;
1015 priv->net_dev = (struct eth_device *)net_dev;
1016 priv->dpmac_id = dpmac_id;
1017 debug("%s dpmac_id=%d\n", __func__, dpmac_id);
1019 err = ldpaa_eth_netdev_init(net_dev, enet_if);
1021 goto err_netdev_init;
1023 debug("ldpaa ethernet: Probed interface %s\n", net_dev->name);
1028 net_dev->priv = NULL;