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 "ldpaa_eth.h"
20 static int init_phy(struct eth_device *dev)
22 /*TODO for external PHY */
27 static void ldpaa_eth_rx(struct ldpaa_eth_priv *priv,
28 const struct dpaa_fd *fd)
33 struct ldpaa_fas *fas;
35 u32 timeo = (CONFIG_SYS_HZ * 2) / 1000;
37 struct qbman_release_desc releasedesc;
38 struct qbman_swp *swp = dflt_dpio->sw_portal;
40 fd_addr = ldpaa_fd_get_addr(fd);
41 fd_offset = ldpaa_fd_get_offset(fd);
42 fd_length = ldpaa_fd_get_len(fd);
44 debug("Rx frame:data addr=0x%p size=0x%x\n", (u64 *)fd_addr, fd_length);
46 if (fd->simple.frc & LDPAA_FD_FRC_FASV) {
47 /* Read the frame annotation status word and check for errors */
48 fas = (struct ldpaa_fas *)
49 ((uint8_t *)(fd_addr) +
50 dflt_dpni->buf_layout.private_data_size);
51 status = le32_to_cpu(fas->status);
52 if (status & LDPAA_ETH_RX_ERR_MASK) {
53 printf("Rx frame error(s): 0x%08x\n",
54 status & LDPAA_ETH_RX_ERR_MASK);
56 } else if (status & LDPAA_ETH_RX_UNSUPP_MASK) {
57 printf("Unsupported feature in bitmask: 0x%08x\n",
58 status & LDPAA_ETH_RX_UNSUPP_MASK);
63 debug("Rx frame: To Upper layer\n");
64 net_process_received_packet((uint8_t *)(fd_addr) + fd_offset,
68 flush_dcache_range(fd_addr, fd_addr + LDPAA_ETH_RX_BUFFER_SIZE);
69 qbman_release_desc_clear(&releasedesc);
70 qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid);
71 time_start = get_timer(0);
73 /* Release buffer into the QBMAN */
74 err = qbman_swp_release(swp, &releasedesc, &fd_addr, 1);
75 } while (get_timer(time_start) < timeo && err == -EBUSY);
78 printf("Rx frame: QBMAN buffer release fails\n");
83 static int ldpaa_eth_pull_dequeue_rx(struct eth_device *dev)
85 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)dev->priv;
86 const struct ldpaa_dq *dq;
87 const struct dpaa_fd *fd;
88 int i = 5, err = 0, status;
89 u32 timeo = (CONFIG_SYS_HZ * 2) / 1000;
91 static struct qbman_pull_desc pulldesc;
92 struct qbman_swp *swp = dflt_dpio->sw_portal;
95 qbman_pull_desc_clear(&pulldesc);
96 qbman_pull_desc_set_numframes(&pulldesc, 1);
97 qbman_pull_desc_set_fq(&pulldesc, priv->rx_dflt_fqid);
99 err = qbman_swp_pull(swp, &pulldesc);
101 printf("Dequeue frames error:0x%08x\n", err);
105 time_start = get_timer(0);
108 dq = qbman_swp_dqrr_next(swp);
109 } while (get_timer(time_start) < timeo && !dq);
112 /* Check for valid frame. If not sent a consume
113 * confirmation to QBMAN otherwise give it to NADK
114 * application and then send consume confirmation to
117 status = (uint8_t)ldpaa_dq_flags(dq);
118 if ((status & LDPAA_DQ_STAT_VALIDFRAME) == 0) {
119 debug("Dequeue RX frames:");
120 debug("No frame delivered\n");
122 qbman_swp_dqrr_consume(swp, dq);
126 fd = ldpaa_dq_fd(dq);
128 /* Obtain FD and process it */
129 ldpaa_eth_rx(priv, fd);
130 qbman_swp_dqrr_consume(swp, dq);
134 debug("No DQRR entries\n");
142 static int ldpaa_eth_tx(struct eth_device *net_dev, void *buf, int len)
144 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
147 int data_offset, err;
148 u32 timeo = (CONFIG_SYS_HZ * 10) / 1000;
150 struct qbman_swp *swp = dflt_dpio->sw_portal;
151 struct qbman_eq_desc ed;
152 struct qbman_release_desc releasedesc;
154 /* Setup the FD fields */
155 memset(&fd, 0, sizeof(fd));
157 data_offset = priv->tx_data_offset;
160 err = qbman_swp_acquire(dflt_dpio->sw_portal,
161 dflt_dpbp->dpbp_attr.bpid,
163 } while (err == -EBUSY);
166 printf("qbman_swp_acquire() failed\n");
170 debug("TX data: malloc buffer start=0x%p\n", (u64 *)buffer_start);
172 memcpy(((uint8_t *)(buffer_start) + data_offset), buf, len);
174 flush_dcache_range(buffer_start, buffer_start +
175 LDPAA_ETH_RX_BUFFER_SIZE);
177 ldpaa_fd_set_addr(&fd, (u64)buffer_start);
178 ldpaa_fd_set_offset(&fd, (uint16_t)(data_offset));
179 ldpaa_fd_set_bpid(&fd, dflt_dpbp->dpbp_attr.bpid);
180 ldpaa_fd_set_len(&fd, len);
182 fd.simple.ctrl = LDPAA_FD_CTRL_ASAL | LDPAA_FD_CTRL_PTA |
185 qbman_eq_desc_clear(&ed);
186 qbman_eq_desc_set_no_orp(&ed, 0);
187 qbman_eq_desc_set_qd(&ed, priv->tx_qdid, priv->tx_flow_id, 0);
189 time_start = get_timer(0);
191 while (get_timer(time_start) < timeo) {
192 err = qbman_swp_enqueue(swp, &ed,
193 (const struct qbman_fd *)(&fd));
199 printf("error enqueueing Tx frame\n");
206 qbman_release_desc_clear(&releasedesc);
207 qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid);
208 time_start = get_timer(0);
210 /* Release buffer into the QBMAN */
211 err = qbman_swp_release(swp, &releasedesc, &buffer_start, 1);
212 } while (get_timer(time_start) < timeo && err == -EBUSY);
215 printf("TX data: QBMAN buffer release fails\n");
220 static int ldpaa_eth_open(struct eth_device *net_dev, bd_t *bd)
222 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
223 struct dpni_queue_attr rx_queue_attr;
224 struct dpmac_link_state dpmac_link_state = { 0 };
227 if (net_dev->state == ETH_STATE_ACTIVE)
230 if (get_mc_boot_status() != 0) {
231 printf("ERROR (MC is not booted)\n");
235 if (get_dpl_apply_status() == 0) {
236 printf("ERROR (DPL is deployed. No device available)\n");
239 /* DPMAC initialization */
240 err = ldpaa_dpmac_setup(priv);
242 goto err_dpmac_setup;
244 /* DPMAC binding DPNI */
245 err = ldpaa_dpmac_bind(priv);
249 /* DPNI initialization */
250 err = ldpaa_dpni_setup(priv);
254 err = ldpaa_dpbp_setup();
258 /* DPNI binding DPBP */
259 err = ldpaa_dpni_bind(priv);
263 err = dpni_add_mac_addr(dflt_mc_io, MC_CMD_NO_FLAGS,
264 dflt_dpni->dpni_handle, net_dev->enetaddr);
266 printf("dpni_add_mac_addr() failed\n");
271 /* TODO Check this path */
272 err = phy_startup(priv->phydev);
274 printf("%s: Could not initialize\n", priv->phydev->dev->name);
278 priv->phydev->speed = SPEED_1000;
279 priv->phydev->link = 1;
280 priv->phydev->duplex = DUPLEX_FULL;
283 err = dpni_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
285 printf("dpni_enable() failed\n");
289 dpmac_link_state.rate = SPEED_1000;
290 dpmac_link_state.options = DPMAC_LINK_OPT_AUTONEG;
291 dpmac_link_state.up = 1;
292 err = dpmac_set_link_state(dflt_mc_io, MC_CMD_NO_FLAGS,
293 priv->dpmac_handle, &dpmac_link_state);
295 printf("dpmac_set_link_state() failed\n");
298 /* TODO: support multiple Rx flows */
299 err = dpni_get_rx_flow(dflt_mc_io, MC_CMD_NO_FLAGS,
300 dflt_dpni->dpni_handle, 0, 0, &rx_queue_attr);
302 printf("dpni_get_rx_flow() failed\n");
306 priv->rx_dflt_fqid = rx_queue_attr.fqid;
308 err = dpni_get_qdid(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle,
311 printf("dpni_get_qdid() failed\n");
315 if (!priv->phydev->link)
316 printf("%s: No link.\n", priv->phydev->dev->name);
318 return priv->phydev->link ? 0 : -1;
322 dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
327 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
333 static void ldpaa_eth_stop(struct eth_device *net_dev)
335 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
338 if ((net_dev->state == ETH_STATE_PASSIVE) ||
339 (net_dev->state == ETH_STATE_INIT))
342 err = dprc_disconnect(dflt_mc_io, MC_CMD_NO_FLAGS,
343 dflt_dprc_handle, &dpmac_endpoint);
345 printf("dprc_disconnect() failed dpmac_endpoint\n");
347 err = dpmac_destroy(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
349 printf("dpmac_destroy() failed\n");
351 /* Stop Tx and Rx traffic */
352 err = dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
354 printf("dpni_disable() failed\n");
357 phy_shutdown(priv->phydev);
361 dpni_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
362 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
365 static void ldpaa_dpbp_drain_cnt(int count)
367 uint64_t buf_array[7];
374 ret = qbman_swp_acquire(dflt_dpio->sw_portal,
375 dflt_dpbp->dpbp_attr.bpid,
378 printf("qbman_swp_acquire() failed\n");
381 for (i = 0; i < ret; i++) {
382 addr = (void *)buf_array[i];
383 debug("Free: buffer addr =0x%p\n", addr);
389 static void ldpaa_dpbp_drain(void)
392 for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7)
393 ldpaa_dpbp_drain_cnt(7);
396 static int ldpaa_bp_add_7(uint16_t bpid)
398 uint64_t buf_array[7];
401 struct qbman_release_desc rd;
403 for (i = 0; i < 7; i++) {
404 addr = memalign(L1_CACHE_BYTES, LDPAA_ETH_RX_BUFFER_SIZE);
406 printf("addr allocation failed\n");
409 memset(addr, 0x00, LDPAA_ETH_RX_BUFFER_SIZE);
410 flush_dcache_range((u64)addr,
411 (u64)(addr + LDPAA_ETH_RX_BUFFER_SIZE));
413 buf_array[i] = (uint64_t)addr;
414 debug("Release: buffer addr =0x%p\n", addr);
418 /* In case the portal is busy, retry until successful.
419 * This function is guaranteed to succeed in a reasonable amount
425 qbman_release_desc_clear(&rd);
426 qbman_release_desc_set_bpid(&rd, bpid);
427 } while (qbman_swp_release(dflt_dpio->sw_portal, &rd, buf_array, i));
438 static int ldpaa_dpbp_seed(uint16_t bpid)
443 for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7) {
444 count = ldpaa_bp_add_7(bpid);
446 printf("Buffer Seed= %d\n", count);
452 static int ldpaa_dpbp_setup(void)
456 err = dpbp_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_attr.id,
457 &dflt_dpbp->dpbp_handle);
459 printf("dpbp_open() failed\n");
463 err = dpbp_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
465 printf("dpbp_enable() failed\n");
469 err = dpbp_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
470 dflt_dpbp->dpbp_handle,
471 &dflt_dpbp->dpbp_attr);
473 printf("dpbp_get_attributes() failed\n");
477 err = ldpaa_dpbp_seed(dflt_dpbp->dpbp_attr.bpid);
479 printf("Buffer seeding failed for DPBP %d (bpid=%d)\n",
480 dflt_dpbp->dpbp_attr.id, dflt_dpbp->dpbp_attr.bpid);
488 dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
490 dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
495 static void ldpaa_dpbp_free(void)
498 dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
499 dpbp_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
500 dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
503 static int ldpaa_dpmac_setup(struct ldpaa_eth_priv *priv)
506 struct dpmac_cfg dpmac_cfg;
508 dpmac_cfg.mac_id = priv->dpmac_id;
509 err = dpmac_create(dflt_mc_io, MC_CMD_NO_FLAGS, &dpmac_cfg,
510 &priv->dpmac_handle);
512 printf("dpmac_create() failed\n");
516 static int ldpaa_dpmac_bind(struct ldpaa_eth_priv *priv)
519 struct dprc_connection_cfg dprc_connection_cfg = {
520 /* If both rates are zero the connection */
521 /* will be configured in "best effort" mode. */
526 memset(&dpmac_endpoint, 0, sizeof(struct dprc_endpoint));
527 sprintf(dpmac_endpoint.type, "dpmac");
528 dpmac_endpoint.id = priv->dpmac_id;
530 memset(&dpni_endpoint, 0, sizeof(struct dprc_endpoint));
531 sprintf(dpni_endpoint.type, "dpni");
532 dpni_endpoint.id = dflt_dpni->dpni_id;
534 err = dprc_connect(dflt_mc_io, MC_CMD_NO_FLAGS,
538 &dprc_connection_cfg);
542 static int ldpaa_dpni_setup(struct ldpaa_eth_priv *priv)
546 /* and get a handle for the DPNI this interface is associate with */
547 err = dpni_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_id,
548 &dflt_dpni->dpni_handle);
550 printf("dpni_open() failed\n");
554 err = dpni_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
555 dflt_dpni->dpni_handle,
556 &dflt_dpni->dpni_attrs);
558 printf("dpni_get_attributes() failed (err=%d)\n", err);
562 /* Configure our buffers' layout */
563 dflt_dpni->buf_layout.options = DPNI_BUF_LAYOUT_OPT_PARSER_RESULT |
564 DPNI_BUF_LAYOUT_OPT_FRAME_STATUS |
565 DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE;
566 dflt_dpni->buf_layout.pass_parser_result = true;
567 dflt_dpni->buf_layout.pass_frame_status = true;
568 dflt_dpni->buf_layout.private_data_size = LDPAA_ETH_SWA_SIZE;
570 err = dpni_set_rx_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
571 dflt_dpni->dpni_handle,
572 &dflt_dpni->buf_layout);
574 printf("dpni_set_rx_buffer_layout() failed");
579 dflt_dpni->buf_layout.options &= ~DPNI_BUF_LAYOUT_OPT_PARSER_RESULT;
580 err = dpni_set_tx_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
581 dflt_dpni->dpni_handle,
582 &dflt_dpni->buf_layout);
584 printf("dpni_set_tx_buffer_layout() failed");
588 /* ... tx-confirm. */
589 dflt_dpni->buf_layout.options &= ~DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE;
590 err = dpni_set_tx_conf_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
591 dflt_dpni->dpni_handle,
592 &dflt_dpni->buf_layout);
594 printf("dpni_set_tx_conf_buffer_layout() failed");
598 /* Now that we've set our tx buffer layout, retrieve the minimum
599 * required tx data offset.
601 err = dpni_get_tx_data_offset(dflt_mc_io, MC_CMD_NO_FLAGS,
602 dflt_dpni->dpni_handle,
603 &priv->tx_data_offset);
605 printf("dpni_get_tx_data_offset() failed\n");
606 goto err_data_offset;
609 /* Warn in case TX data offset is not multiple of 64 bytes. */
610 WARN_ON(priv->tx_data_offset % 64);
612 /* Accomodate SWA space. */
613 priv->tx_data_offset += LDPAA_ETH_SWA_SIZE;
614 debug("priv->tx_data_offset=%d\n", priv->tx_data_offset);
621 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
626 static int ldpaa_dpni_bind(struct ldpaa_eth_priv *priv)
628 struct dpni_pools_cfg pools_params;
629 struct dpni_tx_flow_cfg dflt_tx_flow;
632 pools_params.num_dpbp = 1;
633 pools_params.pools[0].dpbp_id = (uint16_t)dflt_dpbp->dpbp_attr.id;
634 pools_params.pools[0].buffer_size = LDPAA_ETH_RX_BUFFER_SIZE;
635 err = dpni_set_pools(dflt_mc_io, MC_CMD_NO_FLAGS,
636 dflt_dpni->dpni_handle, &pools_params);
638 printf("dpni_set_pools() failed\n");
642 priv->tx_flow_id = DPNI_NEW_FLOW_ID;
643 memset(&dflt_tx_flow, 0, sizeof(dflt_tx_flow));
645 dflt_tx_flow.options = DPNI_TX_FLOW_OPT_ONLY_TX_ERROR;
646 dflt_tx_flow.conf_err_cfg.use_default_queue = 0;
647 dflt_tx_flow.conf_err_cfg.errors_only = 1;
648 err = dpni_set_tx_flow(dflt_mc_io, MC_CMD_NO_FLAGS,
649 dflt_dpni->dpni_handle, &priv->tx_flow_id,
652 printf("dpni_set_tx_flow() failed\n");
659 static int ldpaa_eth_netdev_init(struct eth_device *net_dev,
660 phy_interface_t enet_if)
663 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
665 sprintf(net_dev->name, "DPMAC%d@%s", priv->dpmac_id,
666 phy_interface_strings[enet_if]);
669 net_dev->init = ldpaa_eth_open;
670 net_dev->halt = ldpaa_eth_stop;
671 net_dev->send = ldpaa_eth_tx;
672 net_dev->recv = ldpaa_eth_pull_dequeue_rx;
674 TODO: PHY MDIO information
675 priv->bus = info->bus;
676 priv->phyaddr = info->phy_addr;
677 priv->enet_if = info->enet_if;
680 if (init_phy(net_dev))
683 err = eth_register(net_dev);
685 printf("eth_register() = %d\n", err);
692 int ldpaa_eth_init(int dpmac_id, phy_interface_t enet_if)
694 struct eth_device *net_dev = NULL;
695 struct ldpaa_eth_priv *priv = NULL;
700 net_dev = (struct eth_device *)malloc(sizeof(struct eth_device));
702 printf("eth_device malloc() failed\n");
705 memset(net_dev, 0, sizeof(struct eth_device));
707 /* alloc the ldpaa ethernet private struct */
708 priv = (struct ldpaa_eth_priv *)malloc(sizeof(struct ldpaa_eth_priv));
710 printf("ldpaa_eth_priv malloc() failed\n");
713 memset(priv, 0, sizeof(struct ldpaa_eth_priv));
715 net_dev->priv = (void *)priv;
716 priv->net_dev = (struct eth_device *)net_dev;
717 priv->dpmac_id = dpmac_id;
718 debug("%s dpmac_id=%d\n", __func__, dpmac_id);
720 err = ldpaa_eth_netdev_init(net_dev, enet_if);
722 goto err_netdev_init;
724 debug("ldpaa ethernet: Probed interface %s\n", net_dev->name);
729 net_dev->priv = NULL;