2 * Copyright (C) 2014 Freescale Semiconductor
4 * SPDX-License-Identifier: GPL-2.0+
14 #include <linux/compat.h>
16 #include "ldpaa_eth.h"
19 static int init_phy(struct eth_device *dev)
21 /*TODO for external PHY */
26 static void ldpaa_eth_rx(struct ldpaa_eth_priv *priv,
27 const struct dpaa_fd *fd)
32 struct ldpaa_fas *fas;
34 u32 timeo = (CONFIG_SYS_HZ * 2) / 1000;
36 struct qbman_release_desc releasedesc;
37 struct qbman_swp *swp = dflt_dpio->sw_portal;
39 fd_addr = ldpaa_fd_get_addr(fd);
40 fd_offset = ldpaa_fd_get_offset(fd);
41 fd_length = ldpaa_fd_get_len(fd);
43 debug("Rx frame:data addr=0x%p size=0x%x\n", (u64 *)fd_addr, fd_length);
45 if (fd->simple.frc & LDPAA_FD_FRC_FASV) {
46 /* Read the frame annotation status word and check for errors */
47 fas = (struct ldpaa_fas *)
48 ((uint8_t *)(fd_addr) +
49 priv->buf_layout.private_data_size);
50 status = le32_to_cpu(fas->status);
51 if (status & LDPAA_ETH_RX_ERR_MASK) {
52 printf("Rx frame error(s): 0x%08x\n",
53 status & LDPAA_ETH_RX_ERR_MASK);
55 } else if (status & LDPAA_ETH_RX_UNSUPP_MASK) {
56 printf("Unsupported feature in bitmask: 0x%08x\n",
57 status & LDPAA_ETH_RX_UNSUPP_MASK);
62 debug("Rx frame: To Upper layer\n");
63 net_process_received_packet((uint8_t *)(fd_addr) + fd_offset,
67 flush_dcache_range(fd_addr, fd_addr + LDPAA_ETH_RX_BUFFER_SIZE);
68 qbman_release_desc_clear(&releasedesc);
69 qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid);
70 time_start = get_timer(0);
72 /* Release buffer into the QBMAN */
73 err = qbman_swp_release(swp, &releasedesc, &fd_addr, 1);
74 } while (get_timer(time_start) < timeo && err == -EBUSY);
77 printf("Rx frame: QBMAN buffer release fails\n");
82 static int ldpaa_eth_pull_dequeue_rx(struct eth_device *dev)
84 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)dev->priv;
85 const struct ldpaa_dq *dq;
86 const struct dpaa_fd *fd;
87 int i = 5, err = 0, status;
88 u32 timeo = (CONFIG_SYS_HZ * 2) / 1000;
90 static struct qbman_pull_desc pulldesc;
91 struct qbman_swp *swp = dflt_dpio->sw_portal;
94 qbman_pull_desc_clear(&pulldesc);
95 qbman_pull_desc_set_numframes(&pulldesc, 1);
96 qbman_pull_desc_set_fq(&pulldesc, priv->rx_dflt_fqid);
98 err = qbman_swp_pull(swp, &pulldesc);
100 printf("Dequeue frames error:0x%08x\n", err);
104 time_start = get_timer(0);
107 dq = qbman_swp_dqrr_next(swp);
108 } while (get_timer(time_start) < timeo && !dq);
111 /* Check for valid frame. If not sent a consume
112 * confirmation to QBMAN otherwise give it to NADK
113 * application and then send consume confirmation to
116 status = (uint8_t)ldpaa_dq_flags(dq);
117 if ((status & LDPAA_DQ_STAT_VALIDFRAME) == 0) {
118 debug("Dequeue RX frames:");
119 debug("No frame delivered\n");
121 qbman_swp_dqrr_consume(swp, dq);
125 fd = ldpaa_dq_fd(dq);
127 /* Obtain FD and process it */
128 ldpaa_eth_rx(priv, fd);
129 qbman_swp_dqrr_consume(swp, dq);
133 debug("No DQRR entries\n");
141 static int ldpaa_eth_tx(struct eth_device *net_dev, void *buf, int len)
143 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
146 int data_offset, err;
147 u32 timeo = (CONFIG_SYS_HZ * 10) / 1000;
149 struct qbman_swp *swp = dflt_dpio->sw_portal;
150 struct qbman_eq_desc ed;
151 struct qbman_release_desc releasedesc;
153 /* Setup the FD fields */
154 memset(&fd, 0, sizeof(fd));
156 data_offset = priv->tx_data_offset;
159 err = qbman_swp_acquire(dflt_dpio->sw_portal,
160 dflt_dpbp->dpbp_attr.bpid,
162 } while (err == -EBUSY);
165 printf("qbman_swp_acquire() failed\n");
169 debug("TX data: malloc buffer start=0x%p\n", (u64 *)buffer_start);
171 memcpy(((uint8_t *)(buffer_start) + data_offset), buf, len);
173 flush_dcache_range(buffer_start, buffer_start +
174 LDPAA_ETH_RX_BUFFER_SIZE);
176 ldpaa_fd_set_addr(&fd, (u64)buffer_start);
177 ldpaa_fd_set_offset(&fd, (uint16_t)(data_offset));
178 ldpaa_fd_set_bpid(&fd, dflt_dpbp->dpbp_attr.bpid);
179 ldpaa_fd_set_len(&fd, len);
181 fd.simple.ctrl = LDPAA_FD_CTRL_ASAL | LDPAA_FD_CTRL_PTA |
184 qbman_eq_desc_clear(&ed);
185 qbman_eq_desc_set_no_orp(&ed, 0);
186 qbman_eq_desc_set_qd(&ed, priv->tx_qdid, priv->tx_flow_id, 0);
188 time_start = get_timer(0);
190 while (get_timer(time_start) < timeo) {
191 err = qbman_swp_enqueue(swp, &ed,
192 (const struct qbman_fd *)(&fd));
198 printf("error enqueueing Tx frame\n");
205 qbman_release_desc_clear(&releasedesc);
206 qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid);
207 time_start = get_timer(0);
209 /* Release buffer into the QBMAN */
210 err = qbman_swp_release(swp, &releasedesc, &buffer_start, 1);
211 } while (get_timer(time_start) < timeo && err == -EBUSY);
214 printf("TX data: QBMAN buffer release fails\n");
219 static int ldpaa_eth_open(struct eth_device *net_dev, bd_t *bd)
221 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
222 struct dpni_queue_attr rx_queue_attr;
226 if (net_dev->state == ETH_STATE_ACTIVE)
229 /* DPNI initialization */
230 err = ldpaa_dpni_setup(priv);
234 err = ldpaa_dpbp_setup();
238 /* DPNI binding DPBP */
239 err = ldpaa_dpni_bind(priv);
243 err = dpni_get_primary_mac_addr(dflt_mc_io, MC_CMD_NO_FLAGS,
244 priv->dpni_handle, mac_addr);
246 printf("dpni_get_primary_mac_addr() failed\n");
250 memcpy(net_dev->enetaddr, mac_addr, 0x6);
252 /* setup the MAC address */
253 if (net_dev->enetaddr[0] & 0x01) {
254 printf("%s: MacAddress is multcast address\n", __func__);
259 /* TODO Check this path */
260 err = phy_startup(priv->phydev);
262 printf("%s: Could not initialize\n", priv->phydev->dev->name);
266 priv->phydev->speed = SPEED_1000;
267 priv->phydev->link = 1;
268 priv->phydev->duplex = DUPLEX_FULL;
271 err = dpni_enable(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpni_handle);
273 printf("dpni_enable() failed\n");
277 /* TODO: support multiple Rx flows */
278 err = dpni_get_rx_flow(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpni_handle,
279 0, 0, &rx_queue_attr);
281 printf("dpni_get_rx_flow() failed\n");
285 priv->rx_dflt_fqid = rx_queue_attr.fqid;
287 err = dpni_get_qdid(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpni_handle,
290 printf("dpni_get_qdid() failed\n");
294 if (!priv->phydev->link)
295 printf("%s: No link.\n", priv->phydev->dev->name);
297 return priv->phydev->link ? 0 : -1;
301 dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpni_handle);
305 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpni_handle);
310 static void ldpaa_eth_stop(struct eth_device *net_dev)
312 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
315 if ((net_dev->state == ETH_STATE_PASSIVE) ||
316 (net_dev->state == ETH_STATE_INIT))
318 /* Stop Tx and Rx traffic */
319 err = dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpni_handle);
321 printf("dpni_disable() failed\n");
324 phy_shutdown(priv->phydev);
328 dpni_reset(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpni_handle);
329 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpni_handle);
332 static void ldpaa_dpbp_drain_cnt(int count)
334 uint64_t buf_array[7];
341 ret = qbman_swp_acquire(dflt_dpio->sw_portal,
342 dflt_dpbp->dpbp_attr.bpid,
345 printf("qbman_swp_acquire() failed\n");
348 for (i = 0; i < ret; i++) {
349 addr = (void *)buf_array[i];
350 debug("Free: buffer addr =0x%p\n", addr);
356 static void ldpaa_dpbp_drain(void)
359 for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7)
360 ldpaa_dpbp_drain_cnt(7);
363 static int ldpaa_bp_add_7(uint16_t bpid)
365 uint64_t buf_array[7];
368 struct qbman_release_desc rd;
370 for (i = 0; i < 7; i++) {
371 addr = memalign(L1_CACHE_BYTES, LDPAA_ETH_RX_BUFFER_SIZE);
373 printf("addr allocation failed\n");
376 memset(addr, 0x00, LDPAA_ETH_RX_BUFFER_SIZE);
377 flush_dcache_range((u64)addr,
378 (u64)(addr + LDPAA_ETH_RX_BUFFER_SIZE));
380 buf_array[i] = (uint64_t)addr;
381 debug("Release: buffer addr =0x%p\n", addr);
385 /* In case the portal is busy, retry until successful.
386 * This function is guaranteed to succeed in a reasonable amount
392 qbman_release_desc_clear(&rd);
393 qbman_release_desc_set_bpid(&rd, bpid);
394 } while (qbman_swp_release(dflt_dpio->sw_portal, &rd, buf_array, i));
405 static int ldpaa_dpbp_seed(uint16_t bpid)
410 for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7) {
411 count = ldpaa_bp_add_7(bpid);
413 printf("Buffer Seed= %d\n", count);
419 static int ldpaa_dpbp_setup(void)
423 err = dpbp_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_attr.id,
424 &dflt_dpbp->dpbp_handle);
426 printf("dpbp_open() failed\n");
430 err = dpbp_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
432 printf("dpbp_enable() failed\n");
436 err = dpbp_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
437 dflt_dpbp->dpbp_handle,
438 &dflt_dpbp->dpbp_attr);
440 printf("dpbp_get_attributes() failed\n");
444 err = ldpaa_dpbp_seed(dflt_dpbp->dpbp_attr.bpid);
446 printf("Buffer seeding failed for DPBP %d (bpid=%d)\n",
447 dflt_dpbp->dpbp_attr.id, dflt_dpbp->dpbp_attr.bpid);
455 dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
457 dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
462 static void ldpaa_dpbp_free(void)
465 dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
466 dpbp_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
467 dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
470 static int ldpaa_dpni_setup(struct ldpaa_eth_priv *priv)
474 /* and get a handle for the DPNI this interface is associate with */
475 err = dpni_open(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpni_id,
478 printf("dpni_open() failed\n");
482 err = dpni_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
483 priv->dpni_handle, &priv->dpni_attrs);
485 printf("dpni_get_attributes() failed (err=%d)\n", err);
489 /* Configure our buffers' layout */
490 priv->buf_layout.options = DPNI_BUF_LAYOUT_OPT_PARSER_RESULT |
491 DPNI_BUF_LAYOUT_OPT_FRAME_STATUS |
492 DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE;
493 priv->buf_layout.pass_parser_result = true;
494 priv->buf_layout.pass_frame_status = true;
495 priv->buf_layout.private_data_size = LDPAA_ETH_SWA_SIZE;
497 err = dpni_set_rx_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
498 priv->dpni_handle, &priv->buf_layout);
500 printf("dpni_set_rx_buffer_layout() failed");
505 priv->buf_layout.options &= ~DPNI_BUF_LAYOUT_OPT_PARSER_RESULT;
506 err = dpni_set_tx_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
507 priv->dpni_handle, &priv->buf_layout);
509 printf("dpni_set_tx_buffer_layout() failed");
513 /* ... tx-confirm. */
514 priv->buf_layout.options &= ~DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE;
515 err = dpni_set_tx_conf_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
519 printf("dpni_set_tx_conf_buffer_layout() failed");
523 /* Now that we've set our tx buffer layout, retrieve the minimum
524 * required tx data offset.
526 err = dpni_get_tx_data_offset(dflt_mc_io, MC_CMD_NO_FLAGS,
527 priv->dpni_handle, &priv->tx_data_offset);
529 printf("dpni_get_tx_data_offset() failed\n");
530 goto err_data_offset;
533 /* Warn in case TX data offset is not multiple of 64 bytes. */
534 WARN_ON(priv->tx_data_offset % 64);
536 /* Accomodate SWA space. */
537 priv->tx_data_offset += LDPAA_ETH_SWA_SIZE;
538 debug("priv->tx_data_offset=%d\n", priv->tx_data_offset);
545 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpni_handle);
550 static int ldpaa_dpni_bind(struct ldpaa_eth_priv *priv)
552 struct dpni_pools_cfg pools_params;
553 struct dpni_tx_flow_cfg dflt_tx_flow;
556 pools_params.num_dpbp = 1;
557 pools_params.pools[0].dpbp_id = (uint16_t)dflt_dpbp->dpbp_attr.id;
558 pools_params.pools[0].buffer_size = LDPAA_ETH_RX_BUFFER_SIZE;
559 err = dpni_set_pools(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpni_handle,
562 printf("dpni_set_pools() failed\n");
566 priv->tx_flow_id = DPNI_NEW_FLOW_ID;
567 memset(&dflt_tx_flow, 0, sizeof(dflt_tx_flow));
569 dflt_tx_flow.options = DPNI_TX_FLOW_OPT_ONLY_TX_ERROR;
570 dflt_tx_flow.conf_err_cfg.use_default_queue = 0;
571 dflt_tx_flow.conf_err_cfg.errors_only = 1;
572 err = dpni_set_tx_flow(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpni_handle,
573 &priv->tx_flow_id, &dflt_tx_flow);
575 printf("dpni_set_tx_flow() failed\n");
582 static int ldpaa_eth_netdev_init(struct eth_device *net_dev)
585 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
587 sprintf(net_dev->name, "DPNI%d", priv->dpni_id);
590 net_dev->init = ldpaa_eth_open;
591 net_dev->halt = ldpaa_eth_stop;
592 net_dev->send = ldpaa_eth_tx;
593 net_dev->recv = ldpaa_eth_pull_dequeue_rx;
595 TODO: PHY MDIO information
596 priv->bus = info->bus;
597 priv->phyaddr = info->phy_addr;
598 priv->enet_if = info->enet_if;
601 if (init_phy(net_dev))
604 err = eth_register(net_dev);
606 printf("eth_register() = %d\n", err);
613 int ldpaa_eth_init(struct dprc_obj_desc obj_desc)
615 struct eth_device *net_dev = NULL;
616 struct ldpaa_eth_priv *priv = NULL;
621 net_dev = (struct eth_device *)malloc(sizeof(struct eth_device));
623 printf("eth_device malloc() failed\n");
626 memset(net_dev, 0, sizeof(struct eth_device));
628 /* alloc the ldpaa ethernet private struct */
629 priv = (struct ldpaa_eth_priv *)malloc(sizeof(struct ldpaa_eth_priv));
631 printf("ldpaa_eth_priv malloc() failed\n");
634 memset(priv, 0, sizeof(struct ldpaa_eth_priv));
636 net_dev->priv = (void *)priv;
637 priv->net_dev = (struct eth_device *)net_dev;
638 priv->dpni_id = obj_desc.id;
640 err = ldpaa_eth_netdev_init(net_dev);
642 goto err_netdev_init;
644 debug("ldpaa ethernet: Probed interface %s\n", net_dev->name);
649 net_dev->priv = NULL;