1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright 2014-2016 Freescale Semiconductor, Inc.
10 #include <asm/types.h>
15 #include <linux/compat.h>
16 #include <fsl-mc/fsl_dpmac.h>
18 #include <fsl-mc/ldpaa_wriop.h>
19 #include "ldpaa_eth.h"
22 static int init_phy(struct eth_device *dev)
24 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)dev->priv;
25 struct phy_device *phydev = NULL;
27 int phy_addr, phy_num;
30 bus = wriop_get_mdio(priv->dpmac_id);
34 for (phy_num = 0; phy_num < WRIOP_MAX_PHY_NUM; phy_num++) {
35 phy_addr = wriop_get_phy_address(priv->dpmac_id, phy_num);
39 phydev = phy_connect(bus, phy_addr, dev,
40 wriop_get_enet_if(priv->dpmac_id));
42 printf("Failed to connect\n");
46 wriop_set_phy_dev(priv->dpmac_id, phy_num, phydev);
47 ret = phy_config(phydev);
53 for (phy_num = 0; phy_num < WRIOP_MAX_PHY_NUM; phy_num++) {
54 phydev = wriop_get_phy_dev(priv->dpmac_id, phy_num);
59 wriop_set_phy_dev(priv->dpmac_id, phy_num, NULL);
69 #define DPNI_STATS_PER_PAGE 6
71 static const char *dpni_statistics[][DPNI_STATS_PER_PAGE] = {
73 "DPNI_CNT_ING_ALL_FRAMES",
74 "DPNI_CNT_ING_ALL_BYTES",
75 "DPNI_CNT_ING_MCAST_FRAMES",
76 "DPNI_CNT_ING_MCAST_BYTES",
77 "DPNI_CNT_ING_BCAST_FRAMES",
78 "DPNI_CNT_ING_BCAST_BYTES",
80 "DPNI_CNT_EGR_ALL_FRAMES",
81 "DPNI_CNT_EGR_ALL_BYTES",
82 "DPNI_CNT_EGR_MCAST_FRAMES",
83 "DPNI_CNT_EGR_MCAST_BYTES",
84 "DPNI_CNT_EGR_BCAST_FRAMES",
85 "DPNI_CNT_EGR_BCAST_BYTES",
87 "DPNI_CNT_ING_FILTERED_FRAMES",
88 "DPNI_CNT_ING_DISCARDED_FRAMES",
89 "DPNI_CNT_ING_NOBUFFER_DISCARDS",
90 "DPNI_CNT_EGR_DISCARDED_FRAMES",
91 "DPNI_CNT_EGR_CNF_FRAMES",
96 static void print_dpni_stats(const char *strings[],
97 struct dpni_statistics dpni_stats)
102 stat = (uint64_t *)&dpni_stats;
103 for (i = 0; i < DPNI_STATS_PER_PAGE; i++) {
104 if (strcmp(strings[i], "\0") == 0)
106 printf("%s= %llu\n", strings[i], *stat);
111 static void ldpaa_eth_get_dpni_counter(void)
114 unsigned int page = 0;
115 struct dpni_statistics dpni_stats;
117 printf("DPNI counters ..\n");
118 for (page = 0; page < 3; page++) {
119 err = dpni_get_statistics(dflt_mc_io, MC_CMD_NO_FLAGS,
120 dflt_dpni->dpni_handle, page,
123 printf("dpni_get_statistics: failed:");
124 printf("%d for page[%d]\n", err, page);
127 print_dpni_stats(dpni_statistics[page], dpni_stats);
131 static void ldpaa_eth_get_dpmac_counter(struct eth_device *net_dev)
133 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
137 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
142 printf("dpmac_get_counter: DPMAC_CNT_ING_BYTE failed\n");
145 printf("\nDPMAC counters ..\n");
146 printf("DPMAC_CNT_ING_BYTE=%lld\n", value);
148 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
150 DPMAC_CNT_ING_FRAME_DISCARD,
153 printf("dpmac_get_counter: DPMAC_CNT_ING_FRAME_DISCARD failed\n");
156 printf("DPMAC_CNT_ING_FRAME_DISCARD=%lld\n", value);
158 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
160 DPMAC_CNT_ING_ALIGN_ERR,
163 printf("dpmac_get_counter: DPMAC_CNT_ING_ALIGN_ERR failed\n");
166 printf("DPMAC_CNT_ING_ALIGN_ERR =%lld\n", value);
168 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
173 printf("dpmac_get_counter: DPMAC_CNT_ING_BYTE failed\n");
176 printf("DPMAC_CNT_ING_BYTE=%lld\n", value);
178 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
180 DPMAC_CNT_ING_ERR_FRAME,
183 printf("dpmac_get_counter: DPMAC_CNT_ING_ERR_FRAME failed\n");
186 printf("DPMAC_CNT_ING_ERR_FRAME=%lld\n", value);
188 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
193 printf("dpmac_get_counter: DPMAC_CNT_EGR_BYTE failed\n");
196 printf("DPMAC_CNT_EGR_BYTE =%lld\n", value);
198 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
200 DPMAC_CNT_EGR_ERR_FRAME ,
203 printf("dpmac_get_counter: DPMAC_CNT_EGR_ERR_FRAME failed\n");
206 printf("DPMAC_CNT_EGR_ERR_FRAME =%lld\n", value);
210 static void ldpaa_eth_rx(struct ldpaa_eth_priv *priv,
211 const struct dpaa_fd *fd)
216 struct ldpaa_fas *fas;
217 uint32_t status, err;
218 u32 timeo = (CONFIG_SYS_HZ * 2) / 1000;
220 struct qbman_release_desc releasedesc;
221 struct qbman_swp *swp = dflt_dpio->sw_portal;
223 fd_addr = ldpaa_fd_get_addr(fd);
224 fd_offset = ldpaa_fd_get_offset(fd);
225 fd_length = ldpaa_fd_get_len(fd);
227 debug("Rx frame:data addr=0x%p size=0x%x\n", (u64 *)fd_addr, fd_length);
229 if (fd->simple.frc & LDPAA_FD_FRC_FASV) {
230 /* Read the frame annotation status word and check for errors */
231 fas = (struct ldpaa_fas *)
232 ((uint8_t *)(fd_addr) +
233 dflt_dpni->buf_layout.private_data_size);
234 status = le32_to_cpu(fas->status);
235 if (status & LDPAA_ETH_RX_ERR_MASK) {
236 printf("Rx frame error(s): 0x%08x\n",
237 status & LDPAA_ETH_RX_ERR_MASK);
239 } else if (status & LDPAA_ETH_RX_UNSUPP_MASK) {
240 printf("Unsupported feature in bitmask: 0x%08x\n",
241 status & LDPAA_ETH_RX_UNSUPP_MASK);
246 debug("Rx frame: To Upper layer\n");
247 net_process_received_packet((uint8_t *)(fd_addr) + fd_offset,
251 flush_dcache_range(fd_addr, fd_addr + LDPAA_ETH_RX_BUFFER_SIZE);
252 qbman_release_desc_clear(&releasedesc);
253 qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid);
254 time_start = get_timer(0);
256 /* Release buffer into the QBMAN */
257 err = qbman_swp_release(swp, &releasedesc, &fd_addr, 1);
258 } while (get_timer(time_start) < timeo && err == -EBUSY);
261 printf("Rx frame: QBMAN buffer release fails\n");
266 static int ldpaa_eth_pull_dequeue_rx(struct eth_device *dev)
268 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)dev->priv;
269 const struct ldpaa_dq *dq;
270 const struct dpaa_fd *fd;
271 int i = 5, err = 0, status;
272 u32 timeo = (CONFIG_SYS_HZ * 2) / 1000;
274 static struct qbman_pull_desc pulldesc;
275 struct qbman_swp *swp = dflt_dpio->sw_portal;
278 qbman_pull_desc_clear(&pulldesc);
279 qbman_pull_desc_set_numframes(&pulldesc, 1);
280 qbman_pull_desc_set_fq(&pulldesc, priv->rx_dflt_fqid);
282 err = qbman_swp_pull(swp, &pulldesc);
284 printf("Dequeue frames error:0x%08x\n", err);
288 time_start = get_timer(0);
291 dq = qbman_swp_dqrr_next(swp);
292 } while (get_timer(time_start) < timeo && !dq);
295 /* Check for valid frame. If not sent a consume
296 * confirmation to QBMAN otherwise give it to NADK
297 * application and then send consume confirmation to
300 status = (uint8_t)ldpaa_dq_flags(dq);
301 if ((status & LDPAA_DQ_STAT_VALIDFRAME) == 0) {
302 debug("Dequeue RX frames:");
303 debug("No frame delivered\n");
305 qbman_swp_dqrr_consume(swp, dq);
309 fd = ldpaa_dq_fd(dq);
311 /* Obtain FD and process it */
312 ldpaa_eth_rx(priv, fd);
313 qbman_swp_dqrr_consume(swp, dq);
317 debug("No DQRR entries\n");
325 static int ldpaa_eth_tx(struct eth_device *net_dev, void *buf, int len)
327 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
330 int data_offset, err;
331 u32 timeo = (CONFIG_SYS_HZ * 10) / 1000;
333 struct qbman_swp *swp = dflt_dpio->sw_portal;
334 struct qbman_eq_desc ed;
335 struct qbman_release_desc releasedesc;
337 /* Setup the FD fields */
338 memset(&fd, 0, sizeof(fd));
340 data_offset = priv->tx_data_offset;
343 err = qbman_swp_acquire(dflt_dpio->sw_portal,
344 dflt_dpbp->dpbp_attr.bpid,
346 } while (err == -EBUSY);
349 printf("qbman_swp_acquire() failed\n");
353 debug("TX data: malloc buffer start=0x%p\n", (u64 *)buffer_start);
355 memcpy(((uint8_t *)(buffer_start) + data_offset), buf, len);
357 flush_dcache_range(buffer_start, buffer_start +
358 LDPAA_ETH_RX_BUFFER_SIZE);
360 ldpaa_fd_set_addr(&fd, (u64)buffer_start);
361 ldpaa_fd_set_offset(&fd, (uint16_t)(data_offset));
362 ldpaa_fd_set_bpid(&fd, dflt_dpbp->dpbp_attr.bpid);
363 ldpaa_fd_set_len(&fd, len);
365 fd.simple.ctrl = LDPAA_FD_CTRL_ASAL | LDPAA_FD_CTRL_PTA |
368 qbman_eq_desc_clear(&ed);
369 qbman_eq_desc_set_no_orp(&ed, 0);
370 qbman_eq_desc_set_qd(&ed, priv->tx_qdid, priv->tx_flow_id, 0);
372 time_start = get_timer(0);
374 while (get_timer(time_start) < timeo) {
375 err = qbman_swp_enqueue(swp, &ed,
376 (const struct qbman_fd *)(&fd));
382 printf("error enqueueing Tx frame\n");
389 qbman_release_desc_clear(&releasedesc);
390 qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid);
391 time_start = get_timer(0);
393 /* Release buffer into the QBMAN */
394 err = qbman_swp_release(swp, &releasedesc, &buffer_start, 1);
395 } while (get_timer(time_start) < timeo && err == -EBUSY);
398 printf("TX data: QBMAN buffer release fails\n");
403 static int ldpaa_get_dpmac_state(struct ldpaa_eth_priv *priv,
404 struct dpmac_link_state *state)
406 phy_interface_t enet_if;
409 struct phy_device *phydev = NULL;
413 /* let's start off with maximum capabilities */
414 enet_if = wriop_get_enet_if(priv->dpmac_id);
416 case PHY_INTERFACE_MODE_XGMII:
417 state->rate = SPEED_10000;
420 state->rate = SPEED_1000;
427 state->options |= DPMAC_LINK_OPT_AUTONEG;
429 /* start the phy devices one by one and update the dpmac state */
430 for (phy_num = 0; phy_num < WRIOP_MAX_PHY_NUM; phy_num++) {
431 phydev = wriop_get_phy_dev(priv->dpmac_id, phy_num);
436 err = phy_startup(phydev);
438 printf("%s: Could not initialize\n", phydev->dev->name);
443 state->rate = min(state->rate, (uint32_t)phydev->speed);
445 state->options |= DPMAC_LINK_OPT_HALF_DUPLEX;
446 if (!phydev->autoneg)
447 state->options &= ~DPMAC_LINK_OPT_AUTONEG;
449 /* break out of loop even if one phy is down */
456 state->options &= ~DPMAC_LINK_OPT_AUTONEG;
467 static int ldpaa_eth_open(struct eth_device *net_dev, bd_t *bd)
469 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
470 struct dpmac_link_state dpmac_link_state = { 0 };
472 struct dpni_link_state link_state;
475 struct dpni_queue d_queue;
477 if (net_dev->state == ETH_STATE_ACTIVE)
480 if (get_mc_boot_status() != 0) {
481 printf("ERROR (MC is not booted)\n");
485 if (get_dpl_apply_status() == 0) {
486 printf("ERROR (DPL is deployed. No device available)\n");
490 /* DPMAC initialization */
491 err = ldpaa_dpmac_setup(priv);
493 goto err_dpmac_setup;
495 err = ldpaa_get_dpmac_state(priv, &dpmac_link_state);
499 /* DPMAC binding DPNI */
500 err = ldpaa_dpmac_bind(priv);
504 /* DPNI initialization */
505 err = ldpaa_dpni_setup(priv);
509 err = ldpaa_dpbp_setup();
513 /* DPNI binding DPBP */
514 err = ldpaa_dpni_bind(priv);
518 err = dpni_add_mac_addr(dflt_mc_io, MC_CMD_NO_FLAGS,
519 dflt_dpni->dpni_handle, net_dev->enetaddr);
521 printf("dpni_add_mac_addr() failed\n");
525 err = dpni_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
527 printf("dpni_enable() failed\n");
531 err = dpmac_set_link_state(dflt_mc_io, MC_CMD_NO_FLAGS,
532 priv->dpmac_handle, &dpmac_link_state);
534 printf("dpmac_set_link_state() failed\n");
539 printf("DPMAC link status: %d - ", dpmac_link_state.up);
540 dpmac_link_state.up == 0 ? printf("down\n") :
541 dpmac_link_state.up == 1 ? printf("up\n") : printf("error state\n");
543 err = dpni_get_link_state(dflt_mc_io, MC_CMD_NO_FLAGS,
544 dflt_dpni->dpni_handle, &link_state);
546 printf("dpni_get_link_state() failed\n");
550 printf("DPNI link status: %d - ", link_state.up);
551 link_state.up == 0 ? printf("down\n") :
552 link_state.up == 1 ? printf("up\n") : printf("error state\n");
555 memset(&d_queue, 0, sizeof(struct dpni_queue));
556 err = dpni_get_queue(dflt_mc_io, MC_CMD_NO_FLAGS,
557 dflt_dpni->dpni_handle, DPNI_QUEUE_RX,
560 printf("dpni_get_queue failed\n");
564 priv->rx_dflt_fqid = d_queue.fqid;
566 err = dpni_get_qdid(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle,
569 printf("dpni_get_qdid() failed\n");
573 return dpmac_link_state.up;
577 dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
581 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
584 dpmac_close(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
585 dpmac_destroy(dflt_mc_io,
587 MC_CMD_NO_FLAGS, priv->dpmac_id);
592 static void ldpaa_eth_stop(struct eth_device *net_dev)
594 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
597 struct phy_device *phydev = NULL;
601 if ((net_dev->state == ETH_STATE_PASSIVE) ||
602 (net_dev->state == ETH_STATE_INIT))
606 ldpaa_eth_get_dpni_counter();
607 ldpaa_eth_get_dpmac_counter(net_dev);
610 err = dprc_disconnect(dflt_mc_io, MC_CMD_NO_FLAGS,
611 dflt_dprc_handle, &dpmac_endpoint);
613 printf("dprc_disconnect() failed dpmac_endpoint\n");
615 err = dpmac_close(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
617 printf("dpmac_close() failed\n");
619 err = dpmac_destroy(dflt_mc_io,
624 printf("dpmac_destroy() failed\n");
626 /* Stop Tx and Rx traffic */
627 err = dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
629 printf("dpni_disable() failed\n");
632 for (phy_num = 0; phy_num < WRIOP_MAX_PHY_NUM; phy_num++) {
633 phydev = wriop_get_phy_dev(priv->dpmac_id, phy_num);
635 phy_shutdown(phydev);
639 /* Free DPBP handle and reset. */
642 dpni_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
644 printf("dpni_reset() failed\n");
646 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
648 printf("dpni_close() failed\n");
651 static void ldpaa_dpbp_drain_cnt(int count)
653 uint64_t buf_array[7];
660 ret = qbman_swp_acquire(dflt_dpio->sw_portal,
661 dflt_dpbp->dpbp_attr.bpid,
664 printf("qbman_swp_acquire() failed\n");
667 for (i = 0; i < ret; i++) {
668 addr = (void *)buf_array[i];
669 debug("Free: buffer addr =0x%p\n", addr);
675 static void ldpaa_dpbp_drain(void)
678 for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7)
679 ldpaa_dpbp_drain_cnt(7);
682 static int ldpaa_bp_add_7(uint16_t bpid)
684 uint64_t buf_array[7];
687 struct qbman_release_desc rd;
689 for (i = 0; i < 7; i++) {
690 addr = memalign(LDPAA_ETH_BUF_ALIGN, LDPAA_ETH_RX_BUFFER_SIZE);
692 printf("addr allocation failed\n");
695 memset(addr, 0x00, LDPAA_ETH_RX_BUFFER_SIZE);
696 flush_dcache_range((u64)addr,
697 (u64)(addr + LDPAA_ETH_RX_BUFFER_SIZE));
699 buf_array[i] = (uint64_t)addr;
700 debug("Release: buffer addr =0x%p\n", addr);
704 /* In case the portal is busy, retry until successful.
705 * This function is guaranteed to succeed in a reasonable amount
711 qbman_release_desc_clear(&rd);
712 qbman_release_desc_set_bpid(&rd, bpid);
713 } while (qbman_swp_release(dflt_dpio->sw_portal, &rd, buf_array, i));
724 static int ldpaa_dpbp_seed(uint16_t bpid)
729 for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7) {
730 count = ldpaa_bp_add_7(bpid);
732 printf("Buffer Seed= %d\n", count);
738 static int ldpaa_dpbp_setup(void)
742 err = dpbp_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_attr.id,
743 &dflt_dpbp->dpbp_handle);
745 printf("dpbp_open() failed\n");
749 err = dpbp_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
751 printf("dpbp_enable() failed\n");
755 err = dpbp_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
756 dflt_dpbp->dpbp_handle,
757 &dflt_dpbp->dpbp_attr);
759 printf("dpbp_get_attributes() failed\n");
763 err = ldpaa_dpbp_seed(dflt_dpbp->dpbp_attr.bpid);
766 printf("Buffer seeding failed for DPBP %d (bpid=%d)\n",
767 dflt_dpbp->dpbp_attr.id, dflt_dpbp->dpbp_attr.bpid);
775 dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
777 dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
782 static void ldpaa_dpbp_free(void)
785 dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
786 dpbp_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
787 dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
790 static int ldpaa_dpmac_version_check(struct fsl_mc_io *mc_io,
791 struct ldpaa_eth_priv *priv)
794 uint16_t major_ver, minor_ver;
796 error = dpmac_get_api_version(dflt_mc_io, 0,
799 if ((major_ver < DPMAC_VER_MAJOR) ||
800 (major_ver == DPMAC_VER_MAJOR && minor_ver < DPMAC_VER_MINOR)) {
801 printf("DPMAC version mismatch found %u.%u,",
802 major_ver, minor_ver);
803 printf("supported version is %u.%u\n",
804 DPMAC_VER_MAJOR, DPMAC_VER_MINOR);
811 static int ldpaa_dpmac_setup(struct ldpaa_eth_priv *priv)
814 struct dpmac_cfg dpmac_cfg;
816 dpmac_cfg.mac_id = priv->dpmac_id;
818 err = dpmac_create(dflt_mc_io,
820 MC_CMD_NO_FLAGS, &dpmac_cfg,
823 printf("dpmac_create() failed\n");
825 err = ldpaa_dpmac_version_check(dflt_mc_io, priv);
827 printf("ldpaa_dpmac_version_check() failed: %d\n", err);
828 goto err_version_check;
831 err = dpmac_open(dflt_mc_io,
834 &priv->dpmac_handle);
836 printf("dpmac_open() failed: %d\n", err);
844 dpmac_destroy(dflt_mc_io,
846 MC_CMD_NO_FLAGS, priv->dpmac_id);
851 static int ldpaa_dpmac_bind(struct ldpaa_eth_priv *priv)
854 struct dprc_connection_cfg dprc_connection_cfg = {
855 /* If both rates are zero the connection */
856 /* will be configured in "best effort" mode. */
862 struct dprc_endpoint dbg_endpoint;
866 memset(&dpmac_endpoint, 0, sizeof(struct dprc_endpoint));
867 strcpy(dpmac_endpoint.type, "dpmac");
868 dpmac_endpoint.id = priv->dpmac_id;
870 memset(&dpni_endpoint, 0, sizeof(struct dprc_endpoint));
871 strcpy(dpni_endpoint.type, "dpni");
872 dpni_endpoint.id = dflt_dpni->dpni_id;
874 err = dprc_connect(dflt_mc_io, MC_CMD_NO_FLAGS,
878 &dprc_connection_cfg);
880 printf("dprc_connect() failed\n");
883 err = dprc_get_connection(dflt_mc_io, MC_CMD_NO_FLAGS,
884 dflt_dprc_handle, &dpni_endpoint,
885 &dbg_endpoint, &state);
886 printf("%s, DPMAC Type= %s\n", __func__, dbg_endpoint.type);
887 printf("%s, DPMAC ID= %d\n", __func__, dbg_endpoint.id);
888 printf("%s, DPMAC State= %d\n", __func__, state);
890 memset(&dbg_endpoint, 0, sizeof(struct dprc_endpoint));
891 err = dprc_get_connection(dflt_mc_io, MC_CMD_NO_FLAGS,
892 dflt_dprc_handle, &dpmac_endpoint,
893 &dbg_endpoint, &state);
894 printf("%s, DPNI Type= %s\n", __func__, dbg_endpoint.type);
895 printf("%s, DPNI ID= %d\n", __func__, dbg_endpoint.id);
896 printf("%s, DPNI State= %d\n", __func__, state);
901 static int ldpaa_dpni_setup(struct ldpaa_eth_priv *priv)
905 /* and get a handle for the DPNI this interface is associate with */
906 err = dpni_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_id,
907 &dflt_dpni->dpni_handle);
909 printf("dpni_open() failed\n");
912 err = dpni_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
913 dflt_dpni->dpni_handle,
914 &dflt_dpni->dpni_attrs);
916 printf("dpni_get_attributes() failed (err=%d)\n", err);
920 /* Configure our buffers' layout */
921 dflt_dpni->buf_layout.options = DPNI_BUF_LAYOUT_OPT_PARSER_RESULT |
922 DPNI_BUF_LAYOUT_OPT_FRAME_STATUS |
923 DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE |
924 DPNI_BUF_LAYOUT_OPT_DATA_ALIGN;
925 dflt_dpni->buf_layout.pass_parser_result = true;
926 dflt_dpni->buf_layout.pass_frame_status = true;
927 dflt_dpni->buf_layout.private_data_size = LDPAA_ETH_SWA_SIZE;
928 /* HW erratum mandates data alignment in multiples of 256 */
929 dflt_dpni->buf_layout.data_align = LDPAA_ETH_BUF_ALIGN;
932 err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
933 dflt_dpni->dpni_handle,
934 &dflt_dpni->buf_layout, DPNI_QUEUE_RX);
936 printf("dpni_set_buffer_layout() failed");
941 /* remove Rx-only options */
942 dflt_dpni->buf_layout.options &= ~(DPNI_BUF_LAYOUT_OPT_DATA_ALIGN |
943 DPNI_BUF_LAYOUT_OPT_PARSER_RESULT);
944 err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
945 dflt_dpni->dpni_handle,
946 &dflt_dpni->buf_layout, DPNI_QUEUE_TX);
948 printf("dpni_set_buffer_layout() failed");
952 /* ... tx-confirm. */
953 dflt_dpni->buf_layout.options &= ~DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE;
954 err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
955 dflt_dpni->dpni_handle,
956 &dflt_dpni->buf_layout,
957 DPNI_QUEUE_TX_CONFIRM);
959 printf("dpni_set_buffer_layout() failed");
963 /* Now that we've set our tx buffer layout, retrieve the minimum
964 * required tx data offset.
966 err = dpni_get_tx_data_offset(dflt_mc_io, MC_CMD_NO_FLAGS,
967 dflt_dpni->dpni_handle,
968 &priv->tx_data_offset);
970 printf("dpni_get_tx_data_offset() failed\n");
971 goto err_data_offset;
974 /* Warn in case TX data offset is not multiple of 64 bytes. */
975 WARN_ON(priv->tx_data_offset % 64);
977 /* Accomodate SWA space. */
978 priv->tx_data_offset += LDPAA_ETH_SWA_SIZE;
979 debug("priv->tx_data_offset=%d\n", priv->tx_data_offset);
986 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
991 static int ldpaa_dpni_bind(struct ldpaa_eth_priv *priv)
993 struct dpni_pools_cfg pools_params;
994 struct dpni_queue tx_queue;
997 memset(&pools_params, 0, sizeof(pools_params));
998 pools_params.num_dpbp = 1;
999 pools_params.pools[0].dpbp_id = (uint16_t)dflt_dpbp->dpbp_attr.id;
1000 pools_params.pools[0].buffer_size = LDPAA_ETH_RX_BUFFER_SIZE;
1001 err = dpni_set_pools(dflt_mc_io, MC_CMD_NO_FLAGS,
1002 dflt_dpni->dpni_handle, &pools_params);
1004 printf("dpni_set_pools() failed\n");
1008 memset(&tx_queue, 0, sizeof(struct dpni_queue));
1010 err = dpni_set_queue(dflt_mc_io, MC_CMD_NO_FLAGS,
1011 dflt_dpni->dpni_handle,
1012 DPNI_QUEUE_TX, 0, 0, &tx_queue);
1015 printf("dpni_set_queue() failed\n");
1019 err = dpni_set_tx_confirmation_mode(dflt_mc_io, MC_CMD_NO_FLAGS,
1020 dflt_dpni->dpni_handle,
1023 printf("dpni_set_tx_confirmation_mode() failed\n");
1030 static int ldpaa_eth_netdev_init(struct eth_device *net_dev,
1031 phy_interface_t enet_if)
1034 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
1036 snprintf(net_dev->name, ETH_NAME_LEN, "DPMAC%d@%s", priv->dpmac_id,
1037 phy_interface_strings[enet_if]);
1039 net_dev->iobase = 0;
1040 net_dev->init = ldpaa_eth_open;
1041 net_dev->halt = ldpaa_eth_stop;
1042 net_dev->send = ldpaa_eth_tx;
1043 net_dev->recv = ldpaa_eth_pull_dequeue_rx;
1045 #ifdef CONFIG_PHYLIB
1046 err = init_phy(net_dev);
1051 err = eth_register(net_dev);
1053 printf("eth_register() = %d\n", err);
1060 int ldpaa_eth_init(int dpmac_id, phy_interface_t enet_if)
1062 struct eth_device *net_dev = NULL;
1063 struct ldpaa_eth_priv *priv = NULL;
1067 net_dev = (struct eth_device *)malloc(sizeof(struct eth_device));
1069 printf("eth_device malloc() failed\n");
1072 memset(net_dev, 0, sizeof(struct eth_device));
1074 /* alloc the ldpaa ethernet private struct */
1075 priv = (struct ldpaa_eth_priv *)malloc(sizeof(struct ldpaa_eth_priv));
1077 printf("ldpaa_eth_priv malloc() failed\n");
1081 memset(priv, 0, sizeof(struct ldpaa_eth_priv));
1083 net_dev->priv = (void *)priv;
1084 priv->net_dev = (struct eth_device *)net_dev;
1085 priv->dpmac_id = dpmac_id;
1086 debug("%s dpmac_id=%d\n", __func__, dpmac_id);
1088 err = ldpaa_eth_netdev_init(net_dev, enet_if);
1090 goto err_netdev_init;
1092 debug("ldpaa ethernet: Probed interface %s\n", net_dev->name);
1097 net_dev->priv = NULL;