1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright 2014-2016 Freescale Semiconductor, Inc.
10 #include <asm/types.h>
16 #include <linux/compat.h>
17 #include <fsl-mc/fsl_dpmac.h>
19 #include <fsl-mc/ldpaa_wriop.h>
20 #include "ldpaa_eth.h"
24 static void init_phy(struct udevice *dev)
26 struct ldpaa_eth_priv *priv = dev_get_priv(dev);
28 priv->phy = dm_eth_phy_connect(dev);
33 phy_config(priv->phy);
36 static int init_phy(struct eth_device *dev)
38 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)dev->priv;
39 struct phy_device *phydev = NULL;
41 int phy_addr, phy_num;
44 bus = wriop_get_mdio(priv->dpmac_id);
48 for (phy_num = 0; phy_num < WRIOP_MAX_PHY_NUM; phy_num++) {
49 phy_addr = wriop_get_phy_address(priv->dpmac_id, phy_num);
53 phydev = phy_connect(bus, phy_addr, dev,
54 wriop_get_enet_if(priv->dpmac_id));
56 printf("Failed to connect\n");
60 wriop_set_phy_dev(priv->dpmac_id, phy_num, phydev);
61 ret = phy_config(phydev);
67 for (phy_num = 0; phy_num < WRIOP_MAX_PHY_NUM; phy_num++) {
68 phydev = wriop_get_phy_dev(priv->dpmac_id, phy_num);
73 wriop_set_phy_dev(priv->dpmac_id, phy_num, NULL);
84 #define DPNI_STATS_PER_PAGE 6
86 static const char *dpni_statistics[][DPNI_STATS_PER_PAGE] = {
88 "DPNI_CNT_ING_ALL_FRAMES",
89 "DPNI_CNT_ING_ALL_BYTES",
90 "DPNI_CNT_ING_MCAST_FRAMES",
91 "DPNI_CNT_ING_MCAST_BYTES",
92 "DPNI_CNT_ING_BCAST_FRAMES",
93 "DPNI_CNT_ING_BCAST_BYTES",
95 "DPNI_CNT_EGR_ALL_FRAMES",
96 "DPNI_CNT_EGR_ALL_BYTES",
97 "DPNI_CNT_EGR_MCAST_FRAMES",
98 "DPNI_CNT_EGR_MCAST_BYTES",
99 "DPNI_CNT_EGR_BCAST_FRAMES",
100 "DPNI_CNT_EGR_BCAST_BYTES",
102 "DPNI_CNT_ING_FILTERED_FRAMES",
103 "DPNI_CNT_ING_DISCARDED_FRAMES",
104 "DPNI_CNT_ING_NOBUFFER_DISCARDS",
105 "DPNI_CNT_EGR_DISCARDED_FRAMES",
106 "DPNI_CNT_EGR_CNF_FRAMES",
111 static void print_dpni_stats(const char *strings[],
112 struct dpni_statistics dpni_stats)
117 stat = (uint64_t *)&dpni_stats;
118 for (i = 0; i < DPNI_STATS_PER_PAGE; i++) {
119 if (strcmp(strings[i], "\0") == 0)
121 printf("%s= %llu\n", strings[i], *stat);
126 static void ldpaa_eth_get_dpni_counter(void)
129 unsigned int page = 0;
130 struct dpni_statistics dpni_stats;
132 printf("DPNI counters ..\n");
133 for (page = 0; page < 3; page++) {
134 err = dpni_get_statistics(dflt_mc_io, MC_CMD_NO_FLAGS,
135 dflt_dpni->dpni_handle, page,
138 printf("dpni_get_statistics: failed:");
139 printf("%d for page[%d]\n", err, page);
142 print_dpni_stats(dpni_statistics[page], dpni_stats);
147 static void ldpaa_eth_get_dpmac_counter(struct udevice *dev)
149 struct ldpaa_eth_priv *priv = dev_get_priv(dev);
151 static void ldpaa_eth_get_dpmac_counter(struct eth_device *net_dev)
153 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
158 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
163 printf("dpmac_get_counter: DPMAC_CNT_ING_BYTE failed\n");
166 printf("\nDPMAC counters ..\n");
167 printf("DPMAC_CNT_ING_BYTE=%lld\n", value);
169 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
171 DPMAC_CNT_ING_FRAME_DISCARD,
174 printf("dpmac_get_counter: DPMAC_CNT_ING_FRAME_DISCARD failed\n");
177 printf("DPMAC_CNT_ING_FRAME_DISCARD=%lld\n", value);
179 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
181 DPMAC_CNT_ING_ALIGN_ERR,
184 printf("dpmac_get_counter: DPMAC_CNT_ING_ALIGN_ERR failed\n");
187 printf("DPMAC_CNT_ING_ALIGN_ERR =%lld\n", value);
189 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
194 printf("dpmac_get_counter: DPMAC_CNT_ING_BYTE failed\n");
197 printf("DPMAC_CNT_ING_BYTE=%lld\n", value);
199 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
201 DPMAC_CNT_ING_ERR_FRAME,
204 printf("dpmac_get_counter: DPMAC_CNT_ING_ERR_FRAME failed\n");
207 printf("DPMAC_CNT_ING_ERR_FRAME=%lld\n", value);
209 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
214 printf("dpmac_get_counter: DPMAC_CNT_EGR_BYTE failed\n");
217 printf("DPMAC_CNT_EGR_BYTE =%lld\n", value);
219 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
221 DPMAC_CNT_EGR_ERR_FRAME ,
224 printf("dpmac_get_counter: DPMAC_CNT_EGR_ERR_FRAME failed\n");
227 printf("DPMAC_CNT_EGR_ERR_FRAME =%lld\n", value);
231 static void ldpaa_eth_rx(struct ldpaa_eth_priv *priv,
232 const struct dpaa_fd *fd)
237 struct ldpaa_fas *fas;
238 uint32_t status, err;
239 u32 timeo = (CONFIG_SYS_HZ * 2) / 1000;
241 struct qbman_release_desc releasedesc;
242 struct qbman_swp *swp = dflt_dpio->sw_portal;
244 fd_addr = ldpaa_fd_get_addr(fd);
245 fd_offset = ldpaa_fd_get_offset(fd);
246 fd_length = ldpaa_fd_get_len(fd);
248 debug("Rx frame:data addr=0x%p size=0x%x\n", (u64 *)fd_addr, fd_length);
250 if (fd->simple.frc & LDPAA_FD_FRC_FASV) {
251 /* Read the frame annotation status word and check for errors */
252 fas = (struct ldpaa_fas *)
253 ((uint8_t *)(fd_addr) +
254 dflt_dpni->buf_layout.private_data_size);
255 status = le32_to_cpu(fas->status);
256 if (status & LDPAA_ETH_RX_ERR_MASK) {
257 printf("Rx frame error(s): 0x%08x\n",
258 status & LDPAA_ETH_RX_ERR_MASK);
260 } else if (status & LDPAA_ETH_RX_UNSUPP_MASK) {
261 printf("Unsupported feature in bitmask: 0x%08x\n",
262 status & LDPAA_ETH_RX_UNSUPP_MASK);
267 debug("Rx frame: To Upper layer\n");
268 net_process_received_packet((uint8_t *)(fd_addr) + fd_offset,
272 flush_dcache_range(fd_addr, fd_addr + LDPAA_ETH_RX_BUFFER_SIZE);
273 qbman_release_desc_clear(&releasedesc);
274 qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid);
275 time_start = get_timer(0);
277 /* Release buffer into the QBMAN */
278 err = qbman_swp_release(swp, &releasedesc, &fd_addr, 1);
279 } while (get_timer(time_start) < timeo && err == -EBUSY);
282 printf("Rx frame: QBMAN buffer release fails\n");
288 static int ldpaa_eth_pull_dequeue_rx(struct udevice *dev,
289 int flags, uchar **packetp)
291 struct ldpaa_eth_priv *priv = dev_get_priv(dev);
293 static int ldpaa_eth_pull_dequeue_rx(struct eth_device *dev)
295 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)dev->priv;
297 const struct ldpaa_dq *dq;
298 const struct dpaa_fd *fd;
299 int i = 5, err = 0, status;
300 u32 timeo = (CONFIG_SYS_HZ * 2) / 1000;
302 static struct qbman_pull_desc pulldesc;
303 struct qbman_swp *swp = dflt_dpio->sw_portal;
306 qbman_pull_desc_clear(&pulldesc);
307 qbman_pull_desc_set_numframes(&pulldesc, 1);
308 qbman_pull_desc_set_fq(&pulldesc, priv->rx_dflt_fqid);
310 err = qbman_swp_pull(swp, &pulldesc);
312 printf("Dequeue frames error:0x%08x\n", err);
316 time_start = get_timer(0);
319 dq = qbman_swp_dqrr_next(swp);
320 } while (get_timer(time_start) < timeo && !dq);
323 /* Check for valid frame. If not sent a consume
324 * confirmation to QBMAN otherwise give it to NADK
325 * application and then send consume confirmation to
328 status = (uint8_t)ldpaa_dq_flags(dq);
329 if ((status & LDPAA_DQ_STAT_VALIDFRAME) == 0) {
330 debug("Dequeue RX frames:");
331 debug("No frame delivered\n");
333 qbman_swp_dqrr_consume(swp, dq);
337 fd = ldpaa_dq_fd(dq);
339 /* Obtain FD and process it */
340 ldpaa_eth_rx(priv, fd);
341 qbman_swp_dqrr_consume(swp, dq);
345 debug("No DQRR entries\n");
354 static int ldpaa_eth_tx(struct udevice *dev, void *buf, int len)
356 struct ldpaa_eth_priv *priv = dev_get_priv(dev);
358 static int ldpaa_eth_tx(struct eth_device *net_dev, void *buf, int len)
360 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
364 int data_offset, err;
365 u32 timeo = (CONFIG_SYS_HZ * 10) / 1000;
367 struct qbman_swp *swp = dflt_dpio->sw_portal;
368 struct qbman_eq_desc ed;
369 struct qbman_release_desc releasedesc;
371 /* Setup the FD fields */
372 memset(&fd, 0, sizeof(fd));
374 data_offset = priv->tx_data_offset;
377 err = qbman_swp_acquire(dflt_dpio->sw_portal,
378 dflt_dpbp->dpbp_attr.bpid,
380 } while (err == -EBUSY);
383 printf("qbman_swp_acquire() failed\n");
387 debug("TX data: malloc buffer start=0x%p\n", (u64 *)buffer_start);
389 memcpy(((uint8_t *)(buffer_start) + data_offset), buf, len);
391 flush_dcache_range(buffer_start, buffer_start +
392 LDPAA_ETH_RX_BUFFER_SIZE);
394 ldpaa_fd_set_addr(&fd, (u64)buffer_start);
395 ldpaa_fd_set_offset(&fd, (uint16_t)(data_offset));
396 ldpaa_fd_set_bpid(&fd, dflt_dpbp->dpbp_attr.bpid);
397 ldpaa_fd_set_len(&fd, len);
399 fd.simple.ctrl = LDPAA_FD_CTRL_ASAL | LDPAA_FD_CTRL_PTA |
402 qbman_eq_desc_clear(&ed);
403 qbman_eq_desc_set_no_orp(&ed, 0);
404 qbman_eq_desc_set_qd(&ed, priv->tx_qdid, priv->tx_flow_id, 0);
406 time_start = get_timer(0);
408 while (get_timer(time_start) < timeo) {
409 err = qbman_swp_enqueue(swp, &ed,
410 (const struct qbman_fd *)(&fd));
416 printf("error enqueueing Tx frame\n");
423 qbman_release_desc_clear(&releasedesc);
424 qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid);
425 time_start = get_timer(0);
427 /* Release buffer into the QBMAN */
428 err = qbman_swp_release(swp, &releasedesc, &buffer_start, 1);
429 } while (get_timer(time_start) < timeo && err == -EBUSY);
432 printf("TX data: QBMAN buffer release fails\n");
437 static struct phy_device *ldpaa_get_phydev(struct ldpaa_eth_priv *priv)
443 struct phy_device *phydev = NULL;
446 /* start the phy devices one by one and update the dpmac state */
447 for (phy_num = 0; phy_num < WRIOP_MAX_PHY_NUM; phy_num++) {
448 phydev = wriop_get_phy_dev(priv->dpmac_id, phy_num);
458 static int ldpaa_get_dpmac_state(struct ldpaa_eth_priv *priv,
459 struct dpmac_link_state *state)
461 phy_interface_t enet_if;
462 struct phy_device *phydev = NULL;
465 /* let's start off with maximum capabilities */
466 enet_if = wriop_get_enet_if(priv->dpmac_id);
468 case PHY_INTERFACE_MODE_XGMII:
469 state->rate = SPEED_10000;
472 state->rate = SPEED_1000;
477 state->options |= DPMAC_LINK_OPT_AUTONEG;
478 phydev = ldpaa_get_phydev(priv);
481 err = phy_startup(phydev);
483 printf("%s: Could not initialize\n", phydev->dev->name);
485 } else if (phydev->link) {
486 state->rate = min(state->rate, (uint32_t)phydev->speed);
488 state->options |= DPMAC_LINK_OPT_HALF_DUPLEX;
489 if (!phydev->autoneg)
490 state->options &= ~DPMAC_LINK_OPT_AUTONEG;
497 state->options &= ~DPMAC_LINK_OPT_AUTONEG;
509 static int ldpaa_eth_open(struct udevice *dev)
511 struct eth_pdata *plat = dev_get_platdata(dev);
512 struct ldpaa_eth_priv *priv = dev_get_priv(dev);
514 static int ldpaa_eth_open(struct eth_device *net_dev, bd_t *bd)
516 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
518 struct dpmac_link_state dpmac_link_state = { 0 };
520 struct dpni_link_state link_state;
523 struct dpni_queue d_queue;
526 if (eth_is_active(dev))
529 if (net_dev->state == ETH_STATE_ACTIVE)
533 if (get_mc_boot_status() != 0) {
534 printf("ERROR (MC is not booted)\n");
538 if (get_dpl_apply_status() == 0) {
539 printf("ERROR (DPL is deployed. No device available)\n");
543 /* DPMAC initialization */
544 err = ldpaa_dpmac_setup(priv);
546 goto err_dpmac_setup;
548 err = ldpaa_get_dpmac_state(priv, &dpmac_link_state);
552 /* DPMAC binding DPNI */
553 err = ldpaa_dpmac_bind(priv);
557 /* DPNI initialization */
558 err = ldpaa_dpni_setup(priv);
562 err = ldpaa_dpbp_setup();
566 /* DPNI binding DPBP */
567 err = ldpaa_dpni_bind(priv);
572 err = dpni_add_mac_addr(dflt_mc_io, MC_CMD_NO_FLAGS,
573 dflt_dpni->dpni_handle, plat->enetaddr);
575 err = dpni_add_mac_addr(dflt_mc_io, MC_CMD_NO_FLAGS,
576 dflt_dpni->dpni_handle, net_dev->enetaddr);
579 printf("dpni_add_mac_addr() failed\n");
583 err = dpni_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
585 printf("dpni_enable() failed\n");
589 err = dpmac_set_link_state(dflt_mc_io, MC_CMD_NO_FLAGS,
590 priv->dpmac_handle, &dpmac_link_state);
592 printf("dpmac_set_link_state() failed\n");
597 printf("DPMAC link status: %d - ", dpmac_link_state.up);
598 dpmac_link_state.up == 0 ? printf("down\n") :
599 dpmac_link_state.up == 1 ? printf("up\n") : printf("error state\n");
601 err = dpni_get_link_state(dflt_mc_io, MC_CMD_NO_FLAGS,
602 dflt_dpni->dpni_handle, &link_state);
604 printf("dpni_get_link_state() failed\n");
608 printf("DPNI link status: %d - ", link_state.up);
609 link_state.up == 0 ? printf("down\n") :
610 link_state.up == 1 ? printf("up\n") : printf("error state\n");
613 memset(&d_queue, 0, sizeof(struct dpni_queue));
614 err = dpni_get_queue(dflt_mc_io, MC_CMD_NO_FLAGS,
615 dflt_dpni->dpni_handle, DPNI_QUEUE_RX,
618 printf("dpni_get_queue failed\n");
622 priv->rx_dflt_fqid = d_queue.fqid;
624 err = dpni_get_qdid(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle,
627 printf("dpni_get_qdid() failed\n");
631 return dpmac_link_state.up;
635 dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
639 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
642 dpmac_close(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
643 dpmac_destroy(dflt_mc_io,
645 MC_CMD_NO_FLAGS, priv->dpmac_id);
651 static void ldpaa_eth_stop(struct udevice *dev)
653 struct ldpaa_eth_priv *priv = dev_get_priv(dev);
655 static void ldpaa_eth_stop(struct eth_device *net_dev)
657 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
659 struct phy_device *phydev = NULL;
663 if (!eth_is_active(dev))
666 if ((net_dev->state == ETH_STATE_PASSIVE) ||
667 (net_dev->state == ETH_STATE_INIT))
672 ldpaa_eth_get_dpni_counter();
674 ldpaa_eth_get_dpmac_counter(dev);
676 ldpaa_eth_get_dpmac_counter(net_dev);
680 err = dprc_disconnect(dflt_mc_io, MC_CMD_NO_FLAGS,
681 dflt_dprc_handle, &dpmac_endpoint);
683 printf("dprc_disconnect() failed dpmac_endpoint\n");
685 err = dpmac_close(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
687 printf("dpmac_close() failed\n");
689 err = dpmac_destroy(dflt_mc_io,
694 printf("dpmac_destroy() failed\n");
696 /* Stop Tx and Rx traffic */
697 err = dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
699 printf("dpni_disable() failed\n");
701 phydev = ldpaa_get_phydev(priv);
703 phy_shutdown(phydev);
705 /* Free DPBP handle and reset. */
708 dpni_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
710 printf("dpni_reset() failed\n");
712 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
714 printf("dpni_close() failed\n");
717 static void ldpaa_dpbp_drain_cnt(int count)
719 uint64_t buf_array[7];
726 ret = qbman_swp_acquire(dflt_dpio->sw_portal,
727 dflt_dpbp->dpbp_attr.bpid,
730 printf("qbman_swp_acquire() failed\n");
733 for (i = 0; i < ret; i++) {
734 addr = (void *)buf_array[i];
735 debug("Free: buffer addr =0x%p\n", addr);
741 static void ldpaa_dpbp_drain(void)
744 for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7)
745 ldpaa_dpbp_drain_cnt(7);
748 static int ldpaa_bp_add_7(uint16_t bpid)
750 uint64_t buf_array[7];
753 struct qbman_release_desc rd;
755 for (i = 0; i < 7; i++) {
756 addr = memalign(LDPAA_ETH_BUF_ALIGN, LDPAA_ETH_RX_BUFFER_SIZE);
758 printf("addr allocation failed\n");
761 memset(addr, 0x00, LDPAA_ETH_RX_BUFFER_SIZE);
762 flush_dcache_range((u64)addr,
763 (u64)(addr + LDPAA_ETH_RX_BUFFER_SIZE));
765 buf_array[i] = (uint64_t)addr;
766 debug("Release: buffer addr =0x%p\n", addr);
770 /* In case the portal is busy, retry until successful.
771 * This function is guaranteed to succeed in a reasonable amount
777 qbman_release_desc_clear(&rd);
778 qbman_release_desc_set_bpid(&rd, bpid);
779 } while (qbman_swp_release(dflt_dpio->sw_portal, &rd, buf_array, i));
790 static int ldpaa_dpbp_seed(uint16_t bpid)
795 for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7) {
796 count = ldpaa_bp_add_7(bpid);
798 printf("Buffer Seed= %d\n", count);
804 static int ldpaa_dpbp_setup(void)
808 err = dpbp_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_attr.id,
809 &dflt_dpbp->dpbp_handle);
811 printf("dpbp_open() failed\n");
815 err = dpbp_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
817 printf("dpbp_enable() failed\n");
821 err = dpbp_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
822 dflt_dpbp->dpbp_handle,
823 &dflt_dpbp->dpbp_attr);
825 printf("dpbp_get_attributes() failed\n");
829 err = ldpaa_dpbp_seed(dflt_dpbp->dpbp_attr.bpid);
832 printf("Buffer seeding failed for DPBP %d (bpid=%d)\n",
833 dflt_dpbp->dpbp_attr.id, dflt_dpbp->dpbp_attr.bpid);
841 dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
843 dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
848 static void ldpaa_dpbp_free(void)
851 dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
852 dpbp_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
853 dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
856 static int ldpaa_dpmac_version_check(struct fsl_mc_io *mc_io,
857 struct ldpaa_eth_priv *priv)
860 uint16_t major_ver, minor_ver;
862 error = dpmac_get_api_version(dflt_mc_io, 0,
865 if ((major_ver < DPMAC_VER_MAJOR) ||
866 (major_ver == DPMAC_VER_MAJOR && minor_ver < DPMAC_VER_MINOR)) {
867 printf("DPMAC version mismatch found %u.%u,",
868 major_ver, minor_ver);
869 printf("supported version is %u.%u\n",
870 DPMAC_VER_MAJOR, DPMAC_VER_MINOR);
877 static int ldpaa_dpmac_setup(struct ldpaa_eth_priv *priv)
880 struct dpmac_cfg dpmac_cfg;
882 dpmac_cfg.mac_id = priv->dpmac_id;
884 err = dpmac_create(dflt_mc_io,
886 MC_CMD_NO_FLAGS, &dpmac_cfg,
889 printf("dpmac_create() failed\n");
891 err = ldpaa_dpmac_version_check(dflt_mc_io, priv);
893 printf("ldpaa_dpmac_version_check() failed: %d\n", err);
894 goto err_version_check;
897 err = dpmac_open(dflt_mc_io,
900 &priv->dpmac_handle);
902 printf("dpmac_open() failed: %d\n", err);
910 dpmac_destroy(dflt_mc_io,
912 MC_CMD_NO_FLAGS, priv->dpmac_id);
917 static int ldpaa_dpmac_bind(struct ldpaa_eth_priv *priv)
920 struct dprc_connection_cfg dprc_connection_cfg = {
921 /* If both rates are zero the connection */
922 /* will be configured in "best effort" mode. */
928 struct dprc_endpoint dbg_endpoint;
932 memset(&dpmac_endpoint, 0, sizeof(struct dprc_endpoint));
933 strcpy(dpmac_endpoint.type, "dpmac");
934 dpmac_endpoint.id = priv->dpmac_id;
936 memset(&dpni_endpoint, 0, sizeof(struct dprc_endpoint));
937 strcpy(dpni_endpoint.type, "dpni");
938 dpni_endpoint.id = dflt_dpni->dpni_id;
940 err = dprc_connect(dflt_mc_io, MC_CMD_NO_FLAGS,
944 &dprc_connection_cfg);
946 printf("dprc_connect() failed\n");
949 err = dprc_get_connection(dflt_mc_io, MC_CMD_NO_FLAGS,
950 dflt_dprc_handle, &dpni_endpoint,
951 &dbg_endpoint, &state);
952 printf("%s, DPMAC Type= %s\n", __func__, dbg_endpoint.type);
953 printf("%s, DPMAC ID= %d\n", __func__, dbg_endpoint.id);
954 printf("%s, DPMAC State= %d\n", __func__, state);
956 memset(&dbg_endpoint, 0, sizeof(struct dprc_endpoint));
957 err = dprc_get_connection(dflt_mc_io, MC_CMD_NO_FLAGS,
958 dflt_dprc_handle, &dpmac_endpoint,
959 &dbg_endpoint, &state);
960 printf("%s, DPNI Type= %s\n", __func__, dbg_endpoint.type);
961 printf("%s, DPNI ID= %d\n", __func__, dbg_endpoint.id);
962 printf("%s, DPNI State= %d\n", __func__, state);
967 static int ldpaa_dpni_setup(struct ldpaa_eth_priv *priv)
971 /* and get a handle for the DPNI this interface is associate with */
972 err = dpni_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_id,
973 &dflt_dpni->dpni_handle);
975 printf("dpni_open() failed\n");
978 err = dpni_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
979 dflt_dpni->dpni_handle,
980 &dflt_dpni->dpni_attrs);
982 printf("dpni_get_attributes() failed (err=%d)\n", err);
986 /* Configure our buffers' layout */
987 dflt_dpni->buf_layout.options = DPNI_BUF_LAYOUT_OPT_PARSER_RESULT |
988 DPNI_BUF_LAYOUT_OPT_FRAME_STATUS |
989 DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE |
990 DPNI_BUF_LAYOUT_OPT_DATA_ALIGN;
991 dflt_dpni->buf_layout.pass_parser_result = true;
992 dflt_dpni->buf_layout.pass_frame_status = true;
993 dflt_dpni->buf_layout.private_data_size = LDPAA_ETH_SWA_SIZE;
994 /* HW erratum mandates data alignment in multiples of 256 */
995 dflt_dpni->buf_layout.data_align = LDPAA_ETH_BUF_ALIGN;
998 err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
999 dflt_dpni->dpni_handle,
1000 &dflt_dpni->buf_layout, DPNI_QUEUE_RX);
1002 printf("dpni_set_buffer_layout() failed");
1003 goto err_buf_layout;
1007 /* remove Rx-only options */
1008 dflt_dpni->buf_layout.options &= ~(DPNI_BUF_LAYOUT_OPT_DATA_ALIGN |
1009 DPNI_BUF_LAYOUT_OPT_PARSER_RESULT);
1010 err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
1011 dflt_dpni->dpni_handle,
1012 &dflt_dpni->buf_layout, DPNI_QUEUE_TX);
1014 printf("dpni_set_buffer_layout() failed");
1015 goto err_buf_layout;
1018 /* ... tx-confirm. */
1019 dflt_dpni->buf_layout.options &= ~DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE;
1020 err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
1021 dflt_dpni->dpni_handle,
1022 &dflt_dpni->buf_layout,
1023 DPNI_QUEUE_TX_CONFIRM);
1025 printf("dpni_set_buffer_layout() failed");
1026 goto err_buf_layout;
1029 /* Now that we've set our tx buffer layout, retrieve the minimum
1030 * required tx data offset.
1032 err = dpni_get_tx_data_offset(dflt_mc_io, MC_CMD_NO_FLAGS,
1033 dflt_dpni->dpni_handle,
1034 &priv->tx_data_offset);
1036 printf("dpni_get_tx_data_offset() failed\n");
1037 goto err_data_offset;
1040 /* Warn in case TX data offset is not multiple of 64 bytes. */
1041 WARN_ON(priv->tx_data_offset % 64);
1043 /* Accomodate SWA space. */
1044 priv->tx_data_offset += LDPAA_ETH_SWA_SIZE;
1045 debug("priv->tx_data_offset=%d\n", priv->tx_data_offset);
1052 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
1057 static int ldpaa_dpni_bind(struct ldpaa_eth_priv *priv)
1059 struct dpni_pools_cfg pools_params;
1060 struct dpni_queue tx_queue;
1063 memset(&pools_params, 0, sizeof(pools_params));
1064 pools_params.num_dpbp = 1;
1065 pools_params.pools[0].dpbp_id = (uint16_t)dflt_dpbp->dpbp_attr.id;
1066 pools_params.pools[0].buffer_size = LDPAA_ETH_RX_BUFFER_SIZE;
1067 err = dpni_set_pools(dflt_mc_io, MC_CMD_NO_FLAGS,
1068 dflt_dpni->dpni_handle, &pools_params);
1070 printf("dpni_set_pools() failed\n");
1074 memset(&tx_queue, 0, sizeof(struct dpni_queue));
1076 err = dpni_set_queue(dflt_mc_io, MC_CMD_NO_FLAGS,
1077 dflt_dpni->dpni_handle,
1078 DPNI_QUEUE_TX, 0, 0, &tx_queue);
1081 printf("dpni_set_queue() failed\n");
1085 err = dpni_set_tx_confirmation_mode(dflt_mc_io, MC_CMD_NO_FLAGS,
1086 dflt_dpni->dpni_handle,
1089 printf("dpni_set_tx_confirmation_mode() failed\n");
1096 #ifdef CONFIG_DM_ETH
1097 static int ldpaa_eth_probe(struct udevice *dev)
1099 struct ofnode_phandle_args phandle;
1101 /* Nothing to do if there is no "phy-handle" in the DTS node */
1102 if (dev_read_phandle_with_args(dev, "phy-handle", NULL,
1112 static uint32_t ldpaa_eth_get_dpmac_id(struct udevice *dev)
1114 int port_node = dev_of_offset(dev);
1116 return fdtdec_get_uint(gd->fdt_blob, port_node, "reg", -1);
1119 static const char *ldpaa_eth_get_phy_mode_str(struct udevice *dev)
1121 int port_node = dev_of_offset(dev);
1122 const char *phy_mode_str;
1124 phy_mode_str = fdt_getprop(gd->fdt_blob, port_node,
1125 "phy-connection-type", NULL);
1127 return phy_mode_str;
1129 phy_mode_str = fdt_getprop(gd->fdt_blob, port_node, "phy-mode", NULL);
1130 return phy_mode_str;
1133 static int ldpaa_eth_bind(struct udevice *dev)
1135 const char *phy_mode_str = NULL;
1140 phy_mode_str = ldpaa_eth_get_phy_mode_str(dev);
1142 phy_mode = phy_get_interface_by_name(phy_mode_str);
1143 if (phy_mode == -1) {
1144 dev_err(dev, "incorrect phy mode\n");
1148 dpmac_id = ldpaa_eth_get_dpmac_id(dev);
1149 if (dpmac_id == -1) {
1150 dev_err(dev, "missing reg field from the dpmac node\n");
1154 sprintf(eth_name, "DPMAC%d@%s", dpmac_id, phy_mode_str);
1155 device_set_name(dev, eth_name);
1160 static int ldpaa_eth_ofdata_to_platdata(struct udevice *dev)
1162 struct ldpaa_eth_priv *priv = dev_get_priv(dev);
1163 const char *phy_mode_str;
1165 priv->dpmac_id = ldpaa_eth_get_dpmac_id(dev);
1166 phy_mode_str = ldpaa_eth_get_phy_mode_str(dev);
1167 priv->phy_mode = phy_get_interface_by_name(phy_mode_str);
1172 static const struct eth_ops ldpaa_eth_ops = {
1173 .start = ldpaa_eth_open,
1174 .send = ldpaa_eth_tx,
1175 .recv = ldpaa_eth_pull_dequeue_rx,
1176 .stop = ldpaa_eth_stop,
1179 static const struct udevice_id ldpaa_eth_of_ids[] = {
1180 { .compatible = "fsl,qoriq-mc-dpmac" },
1183 U_BOOT_DRIVER(ldpaa_eth) = {
1184 .name = "ldpaa_eth",
1186 .of_match = ldpaa_eth_of_ids,
1187 .ofdata_to_platdata = ldpaa_eth_ofdata_to_platdata,
1188 .bind = ldpaa_eth_bind,
1189 .probe = ldpaa_eth_probe,
1190 .ops = &ldpaa_eth_ops,
1191 .priv_auto_alloc_size = sizeof(struct ldpaa_eth_priv),
1192 .platdata_auto_alloc_size = sizeof(struct eth_pdata),
1197 static int ldpaa_eth_netdev_init(struct eth_device *net_dev,
1198 phy_interface_t enet_if)
1201 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
1203 snprintf(net_dev->name, ETH_NAME_LEN, "DPMAC%d@%s", priv->dpmac_id,
1204 phy_interface_strings[enet_if]);
1206 net_dev->iobase = 0;
1207 net_dev->init = ldpaa_eth_open;
1208 net_dev->halt = ldpaa_eth_stop;
1209 net_dev->send = ldpaa_eth_tx;
1210 net_dev->recv = ldpaa_eth_pull_dequeue_rx;
1212 #ifdef CONFIG_PHYLIB
1213 err = init_phy(net_dev);
1218 err = eth_register(net_dev);
1220 printf("eth_register() = %d\n", err);
1227 int ldpaa_eth_init(int dpmac_id, phy_interface_t enet_if)
1229 struct eth_device *net_dev = NULL;
1230 struct ldpaa_eth_priv *priv = NULL;
1234 net_dev = (struct eth_device *)malloc(sizeof(struct eth_device));
1236 printf("eth_device malloc() failed\n");
1239 memset(net_dev, 0, sizeof(struct eth_device));
1241 /* alloc the ldpaa ethernet private struct */
1242 priv = (struct ldpaa_eth_priv *)malloc(sizeof(struct ldpaa_eth_priv));
1244 printf("ldpaa_eth_priv malloc() failed\n");
1248 memset(priv, 0, sizeof(struct ldpaa_eth_priv));
1250 net_dev->priv = (void *)priv;
1251 priv->net_dev = (struct eth_device *)net_dev;
1252 priv->dpmac_id = dpmac_id;
1253 debug("%s dpmac_id=%d\n", __func__, dpmac_id);
1255 err = ldpaa_eth_netdev_init(net_dev, enet_if);
1257 goto err_netdev_init;
1259 debug("ldpaa ethernet: Probed interface %s\n", net_dev->name);
1264 net_dev->priv = NULL;