1 /*
2  * Copyright (C) 2014 Freescale Semiconductor
3  *
4  * SPDX-License-Identifier:	GPL-2.0+
5  */
6 
7 #include <common.h>
8 #include <asm/io.h>
9 #include <asm/types.h>
10 #include <malloc.h>
11 #include <net.h>
12 #include <hwconfig.h>
13 #include <phy.h>
14 #include <linux/compat.h>
15 #include <fsl-mc/fsl_dpmac.h>
16 
17 #include "ldpaa_eth.h"
18 
19 #undef CONFIG_PHYLIB
20 static int init_phy(struct eth_device *dev)
21 {
22 	/*TODO for external PHY */
23 
24 	return 0;
25 }
26 
27 #ifdef DEBUG
28 static void ldpaa_eth_get_dpni_counter(void)
29 {
30 	int err = 0;
31 	u64 value;
32 
33 	err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
34 		     dflt_dpni->dpni_handle,
35 		     DPNI_CNT_ING_FRAME,
36 		     &value);
37 	if (err < 0) {
38 		printf("dpni_get_counter: DPNI_CNT_ING_FRAME failed\n");
39 		return;
40 	}
41 	printf("DPNI_CNT_ING_FRAME=%lld\n", value);
42 
43 	err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
44 		     dflt_dpni->dpni_handle,
45 		     DPNI_CNT_ING_BYTE,
46 		     &value);
47 	if (err < 0) {
48 		printf("dpni_get_counter: DPNI_CNT_ING_BYTE failed\n");
49 		return;
50 	}
51 	printf("DPNI_CNT_ING_BYTE=%lld\n", value);
52 
53 	err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
54 		     dflt_dpni->dpni_handle,
55 		     DPNI_CNT_ING_FRAME_DROP ,
56 		     &value);
57 	if (err < 0) {
58 		printf("dpni_get_counter: DPNI_CNT_ING_FRAME_DROP failed\n");
59 		return;
60 	}
61 	printf("DPNI_CNT_ING_FRAME_DROP =%lld\n", value);
62 
63 	err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
64 		     dflt_dpni->dpni_handle,
65 		     DPNI_CNT_ING_FRAME_DISCARD,
66 		     &value);
67 	if (err < 0) {
68 		printf("dpni_get_counter: DPNI_CNT_ING_FRAME_DISCARD failed\n");
69 		return;
70 	}
71 	printf("DPNI_CNT_ING_FRAME_DISCARD=%lld\n", value);
72 
73 	err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
74 		     dflt_dpni->dpni_handle,
75 		     DPNI_CNT_EGR_FRAME,
76 		     &value);
77 	if (err < 0) {
78 		printf("dpni_get_counter: DPNI_CNT_EGR_FRAME failed\n");
79 		return;
80 	}
81 	printf("DPNI_CNT_EGR_FRAME=%lld\n", value);
82 
83 	err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
84 		     dflt_dpni->dpni_handle,
85 		     DPNI_CNT_EGR_BYTE ,
86 		     &value);
87 	if (err < 0) {
88 		printf("dpni_get_counter: DPNI_CNT_EGR_BYTE failed\n");
89 		return;
90 	}
91 	printf("DPNI_CNT_EGR_BYTE =%lld\n", value);
92 
93 	err = dpni_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
94 		     dflt_dpni->dpni_handle,
95 		     DPNI_CNT_EGR_FRAME_DISCARD ,
96 		     &value);
97 	if (err < 0) {
98 		printf("dpni_get_counter: DPNI_CNT_EGR_FRAME_DISCARD failed\n");
99 		return;
100 	}
101 	printf("DPNI_CNT_EGR_FRAME_DISCARD =%lld\n", value);
102 }
103 #endif
104 
105 static void ldpaa_eth_rx(struct ldpaa_eth_priv *priv,
106 			 const struct dpaa_fd *fd)
107 {
108 	u64 fd_addr;
109 	uint16_t fd_offset;
110 	uint32_t fd_length;
111 	struct ldpaa_fas *fas;
112 	uint32_t status, err;
113 	u32 timeo = (CONFIG_SYS_HZ * 2) / 1000;
114 	u32 time_start;
115 	struct qbman_release_desc releasedesc;
116 	struct qbman_swp *swp = dflt_dpio->sw_portal;
117 
118 	fd_addr = ldpaa_fd_get_addr(fd);
119 	fd_offset = ldpaa_fd_get_offset(fd);
120 	fd_length = ldpaa_fd_get_len(fd);
121 
122 	debug("Rx frame:data addr=0x%p size=0x%x\n", (u64 *)fd_addr, fd_length);
123 
124 	if (fd->simple.frc & LDPAA_FD_FRC_FASV) {
125 		/* Read the frame annotation status word and check for errors */
126 		fas = (struct ldpaa_fas *)
127 				((uint8_t *)(fd_addr) +
128 				dflt_dpni->buf_layout.private_data_size);
129 		status = le32_to_cpu(fas->status);
130 		if (status & LDPAA_ETH_RX_ERR_MASK) {
131 			printf("Rx frame error(s): 0x%08x\n",
132 			       status & LDPAA_ETH_RX_ERR_MASK);
133 			goto error;
134 		} else if (status & LDPAA_ETH_RX_UNSUPP_MASK) {
135 			printf("Unsupported feature in bitmask: 0x%08x\n",
136 			       status & LDPAA_ETH_RX_UNSUPP_MASK);
137 			goto error;
138 		}
139 	}
140 
141 	debug("Rx frame: To Upper layer\n");
142 	net_process_received_packet((uint8_t *)(fd_addr) + fd_offset,
143 				    fd_length);
144 
145 error:
146 	flush_dcache_range(fd_addr, fd_addr + LDPAA_ETH_RX_BUFFER_SIZE);
147 	qbman_release_desc_clear(&releasedesc);
148 	qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid);
149 	time_start = get_timer(0);
150 	do {
151 		/* Release buffer into the QBMAN */
152 		err = qbman_swp_release(swp, &releasedesc, &fd_addr, 1);
153 	} while (get_timer(time_start) < timeo && err == -EBUSY);
154 
155 	if (err == -EBUSY)
156 		printf("Rx frame: QBMAN buffer release fails\n");
157 
158 	return;
159 }
160 
161 static int ldpaa_eth_pull_dequeue_rx(struct eth_device *dev)
162 {
163 	struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)dev->priv;
164 	const struct ldpaa_dq *dq;
165 	const struct dpaa_fd *fd;
166 	int i = 5, err = 0, status;
167 	u32 timeo = (CONFIG_SYS_HZ * 2) / 1000;
168 	u32 time_start;
169 	static struct qbman_pull_desc pulldesc;
170 	struct qbman_swp *swp = dflt_dpio->sw_portal;
171 
172 	while (--i) {
173 		qbman_pull_desc_clear(&pulldesc);
174 		qbman_pull_desc_set_numframes(&pulldesc, 1);
175 		qbman_pull_desc_set_fq(&pulldesc, priv->rx_dflt_fqid);
176 
177 		err = qbman_swp_pull(swp, &pulldesc);
178 		if (err < 0) {
179 			printf("Dequeue frames error:0x%08x\n", err);
180 			continue;
181 		}
182 
183 		time_start = get_timer(0);
184 
185 		 do {
186 			dq = qbman_swp_dqrr_next(swp);
187 		} while (get_timer(time_start) < timeo && !dq);
188 
189 		if (dq) {
190 			/* Check for valid frame. If not sent a consume
191 			 * confirmation to QBMAN otherwise give it to NADK
192 			 * application and then send consume confirmation to
193 			 * QBMAN.
194 			 */
195 			status = (uint8_t)ldpaa_dq_flags(dq);
196 			if ((status & LDPAA_DQ_STAT_VALIDFRAME) == 0) {
197 				debug("Dequeue RX frames:");
198 				debug("No frame delivered\n");
199 
200 				qbman_swp_dqrr_consume(swp, dq);
201 				continue;
202 			}
203 
204 			fd = ldpaa_dq_fd(dq);
205 
206 			/* Obtain FD and process it */
207 			ldpaa_eth_rx(priv, fd);
208 			qbman_swp_dqrr_consume(swp, dq);
209 			break;
210 		} else {
211 			err = -ENODATA;
212 			debug("No DQRR entries\n");
213 			break;
214 		}
215 	}
216 
217 	return err;
218 }
219 
220 static int ldpaa_eth_tx(struct eth_device *net_dev, void *buf, int len)
221 {
222 	struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
223 	struct dpaa_fd fd;
224 	u64 buffer_start;
225 	int data_offset, err;
226 	u32 timeo = (CONFIG_SYS_HZ * 10) / 1000;
227 	u32 time_start;
228 	struct qbman_swp *swp = dflt_dpio->sw_portal;
229 	struct qbman_eq_desc ed;
230 	struct qbman_release_desc releasedesc;
231 
232 	/* Setup the FD fields */
233 	memset(&fd, 0, sizeof(fd));
234 
235 	data_offset = priv->tx_data_offset;
236 
237 	do {
238 		err = qbman_swp_acquire(dflt_dpio->sw_portal,
239 					dflt_dpbp->dpbp_attr.bpid,
240 					&buffer_start, 1);
241 	} while (err == -EBUSY);
242 
243 	if (err < 0) {
244 		printf("qbman_swp_acquire() failed\n");
245 		return -ENOMEM;
246 	}
247 
248 	debug("TX data: malloc buffer start=0x%p\n", (u64 *)buffer_start);
249 
250 	memcpy(((uint8_t *)(buffer_start) + data_offset), buf, len);
251 
252 	flush_dcache_range(buffer_start, buffer_start +
253 					LDPAA_ETH_RX_BUFFER_SIZE);
254 
255 	ldpaa_fd_set_addr(&fd, (u64)buffer_start);
256 	ldpaa_fd_set_offset(&fd, (uint16_t)(data_offset));
257 	ldpaa_fd_set_bpid(&fd, dflt_dpbp->dpbp_attr.bpid);
258 	ldpaa_fd_set_len(&fd, len);
259 
260 	fd.simple.ctrl = LDPAA_FD_CTRL_ASAL | LDPAA_FD_CTRL_PTA |
261 				LDPAA_FD_CTRL_PTV1;
262 
263 	qbman_eq_desc_clear(&ed);
264 	qbman_eq_desc_set_no_orp(&ed, 0);
265 	qbman_eq_desc_set_qd(&ed, priv->tx_qdid, priv->tx_flow_id, 0);
266 
267 	time_start = get_timer(0);
268 
269 	while (get_timer(time_start) < timeo) {
270 		err = qbman_swp_enqueue(swp, &ed,
271 				(const struct qbman_fd *)(&fd));
272 		if (err != -EBUSY)
273 			break;
274 	}
275 
276 	if (err < 0) {
277 		printf("error enqueueing Tx frame\n");
278 		goto error;
279 	}
280 
281 	return err;
282 
283 error:
284 	qbman_release_desc_clear(&releasedesc);
285 	qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid);
286 	time_start = get_timer(0);
287 	do {
288 		/* Release buffer into the QBMAN */
289 		err = qbman_swp_release(swp, &releasedesc, &buffer_start, 1);
290 	} while (get_timer(time_start) < timeo && err == -EBUSY);
291 
292 	if (err == -EBUSY)
293 		printf("TX data: QBMAN buffer release fails\n");
294 
295 	return err;
296 }
297 
298 static int ldpaa_eth_open(struct eth_device *net_dev, bd_t *bd)
299 {
300 	struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
301 	struct dpni_queue_attr rx_queue_attr;
302 	struct dpmac_link_state	dpmac_link_state = { 0 };
303 #ifdef DEBUG
304 	struct dpni_link_state link_state;
305 #endif
306 	int err;
307 
308 	if (net_dev->state == ETH_STATE_ACTIVE)
309 		return 0;
310 
311 	if (get_mc_boot_status() != 0) {
312 		printf("ERROR (MC is not booted)\n");
313 		return -ENODEV;
314 	}
315 
316 	if (get_dpl_apply_status() == 0) {
317 		printf("ERROR (DPL is deployed. No device available)\n");
318 		return -ENODEV;
319 	}
320 	/* DPMAC initialization */
321 	err = ldpaa_dpmac_setup(priv);
322 	if (err < 0)
323 		goto err_dpmac_setup;
324 
325 	/* DPMAC binding DPNI */
326 	err = ldpaa_dpmac_bind(priv);
327 	if (err)
328 		goto err_dpamc_bind;
329 
330 	/* DPNI initialization */
331 	err = ldpaa_dpni_setup(priv);
332 	if (err < 0)
333 		goto err_dpni_setup;
334 
335 	err = ldpaa_dpbp_setup();
336 	if (err < 0)
337 		goto err_dpbp_setup;
338 
339 	/* DPNI binding DPBP */
340 	err = ldpaa_dpni_bind(priv);
341 	if (err)
342 		goto err_dpni_bind;
343 
344 	err = dpni_add_mac_addr(dflt_mc_io, MC_CMD_NO_FLAGS,
345 				dflt_dpni->dpni_handle, net_dev->enetaddr);
346 	if (err) {
347 		printf("dpni_add_mac_addr() failed\n");
348 		return err;
349 	}
350 
351 #ifdef CONFIG_PHYLIB
352 	/* TODO Check this path */
353 	err = phy_startup(priv->phydev);
354 	if (err) {
355 		printf("%s: Could not initialize\n", priv->phydev->dev->name);
356 		return err;
357 	}
358 #else
359 	priv->phydev->speed = SPEED_1000;
360 	priv->phydev->link = 1;
361 	priv->phydev->duplex = DUPLEX_FULL;
362 #endif
363 
364 	err = dpni_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
365 	if (err < 0) {
366 		printf("dpni_enable() failed\n");
367 		return err;
368 	}
369 
370 	dpmac_link_state.rate = SPEED_1000;
371 	dpmac_link_state.options = DPMAC_LINK_OPT_AUTONEG;
372 	dpmac_link_state.up = 1;
373 	err = dpmac_set_link_state(dflt_mc_io, MC_CMD_NO_FLAGS,
374 				  priv->dpmac_handle, &dpmac_link_state);
375 	if (err < 0) {
376 		printf("dpmac_set_link_state() failed\n");
377 		return err;
378 	}
379 
380 #ifdef DEBUG
381 	err = dpni_get_link_state(dflt_mc_io, MC_CMD_NO_FLAGS,
382 				  dflt_dpni->dpni_handle, &link_state);
383 	if (err < 0) {
384 		printf("dpni_get_link_state() failed\n");
385 		return err;
386 	}
387 
388 	printf("link status: %d - ", link_state.up);
389 	link_state.up == 0 ? printf("down\n") :
390 	link_state.up == 1 ? printf("up\n") : printf("error state\n");
391 #endif
392 
393 	/* TODO: support multiple Rx flows */
394 	err = dpni_get_rx_flow(dflt_mc_io, MC_CMD_NO_FLAGS,
395 			       dflt_dpni->dpni_handle, 0, 0, &rx_queue_attr);
396 	if (err) {
397 		printf("dpni_get_rx_flow() failed\n");
398 		goto err_rx_flow;
399 	}
400 
401 	priv->rx_dflt_fqid = rx_queue_attr.fqid;
402 
403 	err = dpni_get_qdid(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle,
404 			    &priv->tx_qdid);
405 	if (err) {
406 		printf("dpni_get_qdid() failed\n");
407 		goto err_qdid;
408 	}
409 
410 	if (!priv->phydev->link)
411 		printf("%s: No link.\n", priv->phydev->dev->name);
412 
413 	return priv->phydev->link ? 0 : -1;
414 
415 err_qdid:
416 err_rx_flow:
417 	dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
418 err_dpni_bind:
419 	ldpaa_dpbp_free();
420 err_dpbp_setup:
421 err_dpamc_bind:
422 	dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
423 err_dpni_setup:
424 err_dpmac_setup:
425 	return err;
426 }
427 
428 static void ldpaa_eth_stop(struct eth_device *net_dev)
429 {
430 	struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
431 	int err = 0;
432 
433 	if ((net_dev->state == ETH_STATE_PASSIVE) ||
434 	    (net_dev->state == ETH_STATE_INIT))
435 		return;
436 
437 #ifdef DEBUG
438 	ldpaa_eth_get_dpni_counter();
439 #endif
440 
441 	err = dprc_disconnect(dflt_mc_io, MC_CMD_NO_FLAGS,
442 			      dflt_dprc_handle, &dpmac_endpoint);
443 	if (err < 0)
444 		printf("dprc_disconnect() failed dpmac_endpoint\n");
445 
446 	err = dpmac_destroy(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
447 	if (err < 0)
448 		printf("dpmac_destroy() failed\n");
449 
450 	/* Stop Tx and Rx traffic */
451 	err = dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
452 	if (err < 0)
453 		printf("dpni_disable() failed\n");
454 
455 #ifdef CONFIG_PHYLIB
456 	phy_shutdown(priv->phydev);
457 #endif
458 
459 	ldpaa_dpbp_free();
460 	dpni_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
461 	dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
462 }
463 
464 static void ldpaa_dpbp_drain_cnt(int count)
465 {
466 	uint64_t buf_array[7];
467 	void *addr;
468 	int ret, i;
469 
470 	BUG_ON(count > 7);
471 
472 	do {
473 		ret = qbman_swp_acquire(dflt_dpio->sw_portal,
474 					dflt_dpbp->dpbp_attr.bpid,
475 					buf_array, count);
476 		if (ret < 0) {
477 			printf("qbman_swp_acquire() failed\n");
478 			return;
479 		}
480 		for (i = 0; i < ret; i++) {
481 			addr = (void *)buf_array[i];
482 			debug("Free: buffer addr =0x%p\n", addr);
483 			free(addr);
484 		}
485 	} while (ret);
486 }
487 
488 static void ldpaa_dpbp_drain(void)
489 {
490 	int i;
491 	for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7)
492 		ldpaa_dpbp_drain_cnt(7);
493 }
494 
495 static int ldpaa_bp_add_7(uint16_t bpid)
496 {
497 	uint64_t buf_array[7];
498 	u8 *addr;
499 	int i;
500 	struct qbman_release_desc rd;
501 
502 	for (i = 0; i < 7; i++) {
503 		addr = memalign(LDPAA_ETH_BUF_ALIGN, LDPAA_ETH_RX_BUFFER_SIZE);
504 		if (!addr) {
505 			printf("addr allocation failed\n");
506 			goto err_alloc;
507 		}
508 		memset(addr, 0x00, LDPAA_ETH_RX_BUFFER_SIZE);
509 		flush_dcache_range((u64)addr,
510 				   (u64)(addr + LDPAA_ETH_RX_BUFFER_SIZE));
511 
512 		buf_array[i] = (uint64_t)addr;
513 		debug("Release: buffer addr =0x%p\n", addr);
514 	}
515 
516 release_bufs:
517 	/* In case the portal is busy, retry until successful.
518 	 * This function is guaranteed to succeed in a reasonable amount
519 	 * of time.
520 	 */
521 
522 	do {
523 		mdelay(1);
524 		qbman_release_desc_clear(&rd);
525 		qbman_release_desc_set_bpid(&rd, bpid);
526 	} while (qbman_swp_release(dflt_dpio->sw_portal, &rd, buf_array, i));
527 
528 	return i;
529 
530 err_alloc:
531 	if (i)
532 		goto release_bufs;
533 
534 	return 0;
535 }
536 
537 static int ldpaa_dpbp_seed(uint16_t bpid)
538 {
539 	int i;
540 	int count;
541 
542 	for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7) {
543 		count = ldpaa_bp_add_7(bpid);
544 		if (count < 7)
545 			printf("Buffer Seed= %d\n", count);
546 	}
547 
548 	return 0;
549 }
550 
551 static int ldpaa_dpbp_setup(void)
552 {
553 	int err;
554 
555 	err = dpbp_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_attr.id,
556 			&dflt_dpbp->dpbp_handle);
557 	if (err) {
558 		printf("dpbp_open() failed\n");
559 		goto err_open;
560 	}
561 
562 	err = dpbp_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
563 	if (err) {
564 		printf("dpbp_enable() failed\n");
565 		goto err_enable;
566 	}
567 
568 	err = dpbp_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
569 				  dflt_dpbp->dpbp_handle,
570 				  &dflt_dpbp->dpbp_attr);
571 	if (err) {
572 		printf("dpbp_get_attributes() failed\n");
573 		goto err_get_attr;
574 	}
575 
576 	err = ldpaa_dpbp_seed(dflt_dpbp->dpbp_attr.bpid);
577 	if (err) {
578 		printf("Buffer seeding failed for DPBP %d (bpid=%d)\n",
579 		       dflt_dpbp->dpbp_attr.id, dflt_dpbp->dpbp_attr.bpid);
580 		goto err_seed;
581 	}
582 
583 	return 0;
584 
585 err_seed:
586 err_get_attr:
587 	dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
588 err_enable:
589 	dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
590 err_open:
591 	return err;
592 }
593 
594 static void ldpaa_dpbp_free(void)
595 {
596 	ldpaa_dpbp_drain();
597 	dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
598 	dpbp_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
599 	dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
600 }
601 
602 static int ldpaa_dpmac_setup(struct ldpaa_eth_priv *priv)
603 {
604 	int err = 0;
605 	struct dpmac_cfg dpmac_cfg;
606 
607 	dpmac_cfg.mac_id = priv->dpmac_id;
608 	err = dpmac_create(dflt_mc_io, MC_CMD_NO_FLAGS, &dpmac_cfg,
609 			  &priv->dpmac_handle);
610 	if (err)
611 		printf("dpmac_create() failed\n");
612 	return err;
613 }
614 
615 static int ldpaa_dpmac_bind(struct ldpaa_eth_priv *priv)
616 {
617 	int err = 0;
618 	struct dprc_connection_cfg dprc_connection_cfg = {
619 		/* If both rates are zero the connection */
620 		/* will be configured in "best effort" mode. */
621 		.committed_rate = 0,
622 		.max_rate = 0
623 	};
624 
625 #ifdef DEBUG
626 	struct dprc_endpoint dbg_endpoint;
627 	int state = 0;
628 #endif
629 
630 	memset(&dpmac_endpoint, 0, sizeof(struct dprc_endpoint));
631 	strcpy(dpmac_endpoint.type, "dpmac");
632 	dpmac_endpoint.id = priv->dpmac_id;
633 
634 	memset(&dpni_endpoint, 0, sizeof(struct dprc_endpoint));
635 	strcpy(dpni_endpoint.type, "dpni");
636 	dpni_endpoint.id = dflt_dpni->dpni_id;
637 
638 	err = dprc_connect(dflt_mc_io, MC_CMD_NO_FLAGS,
639 			     dflt_dprc_handle,
640 			     &dpmac_endpoint,
641 			     &dpni_endpoint,
642 			     &dprc_connection_cfg);
643 	if (err)
644 		printf("dprc_connect() failed\n");
645 
646 #ifdef DEBUG
647 	err = dprc_get_connection(dflt_mc_io, MC_CMD_NO_FLAGS,
648 				    dflt_dprc_handle, &dpni_endpoint,
649 				    &dbg_endpoint, &state);
650 	printf("%s, DPMAC Type= %s\n", __func__, dbg_endpoint.type);
651 	printf("%s, DPMAC ID= %d\n", __func__, dbg_endpoint.id);
652 	printf("%s, DPMAC State= %d\n", __func__, state);
653 
654 	memset(&dbg_endpoint, 0, sizeof(struct dprc_endpoint));
655 	err = dprc_get_connection(dflt_mc_io, MC_CMD_NO_FLAGS,
656 				    dflt_dprc_handle, &dpmac_endpoint,
657 				    &dbg_endpoint, &state);
658 	printf("%s, DPNI Type= %s\n", __func__, dbg_endpoint.type);
659 	printf("%s, DPNI ID= %d\n", __func__, dbg_endpoint.id);
660 	printf("%s, DPNI State= %d\n", __func__, state);
661 #endif
662 	return err;
663 }
664 
665 static int ldpaa_dpni_setup(struct ldpaa_eth_priv *priv)
666 {
667 	int err;
668 
669 	/* and get a handle for the DPNI this interface is associate with */
670 	err = dpni_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_id,
671 			&dflt_dpni->dpni_handle);
672 	if (err) {
673 		printf("dpni_open() failed\n");
674 		goto err_open;
675 	}
676 
677 	err = dpni_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
678 				  dflt_dpni->dpni_handle,
679 				  &dflt_dpni->dpni_attrs);
680 	if (err) {
681 		printf("dpni_get_attributes() failed (err=%d)\n", err);
682 		goto err_get_attr;
683 	}
684 
685 	/* Configure our buffers' layout */
686 	dflt_dpni->buf_layout.options = DPNI_BUF_LAYOUT_OPT_PARSER_RESULT |
687 				   DPNI_BUF_LAYOUT_OPT_FRAME_STATUS |
688 				   DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE |
689 				   DPNI_BUF_LAYOUT_OPT_DATA_ALIGN;
690 	dflt_dpni->buf_layout.pass_parser_result = true;
691 	dflt_dpni->buf_layout.pass_frame_status = true;
692 	dflt_dpni->buf_layout.private_data_size = LDPAA_ETH_SWA_SIZE;
693 	/* HW erratum mandates data alignment in multiples of 256 */
694 	dflt_dpni->buf_layout.data_align = LDPAA_ETH_BUF_ALIGN;
695 	/* ...rx, ... */
696 	err = dpni_set_rx_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
697 					dflt_dpni->dpni_handle,
698 					&dflt_dpni->buf_layout);
699 	if (err) {
700 		printf("dpni_set_rx_buffer_layout() failed");
701 		goto err_buf_layout;
702 	}
703 
704 	/* ... tx, ... */
705 	/* remove Rx-only options */
706 	dflt_dpni->buf_layout.options &= ~(DPNI_BUF_LAYOUT_OPT_DATA_ALIGN |
707 				      DPNI_BUF_LAYOUT_OPT_PARSER_RESULT);
708 	err = dpni_set_tx_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
709 					dflt_dpni->dpni_handle,
710 					&dflt_dpni->buf_layout);
711 	if (err) {
712 		printf("dpni_set_tx_buffer_layout() failed");
713 		goto err_buf_layout;
714 	}
715 
716 	/* ... tx-confirm. */
717 	dflt_dpni->buf_layout.options &= ~DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE;
718 	err = dpni_set_tx_conf_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
719 					     dflt_dpni->dpni_handle,
720 					     &dflt_dpni->buf_layout);
721 	if (err) {
722 		printf("dpni_set_tx_conf_buffer_layout() failed");
723 		goto err_buf_layout;
724 	}
725 
726 	/* Now that we've set our tx buffer layout, retrieve the minimum
727 	 * required tx data offset.
728 	 */
729 	err = dpni_get_tx_data_offset(dflt_mc_io, MC_CMD_NO_FLAGS,
730 				      dflt_dpni->dpni_handle,
731 				      &priv->tx_data_offset);
732 	if (err) {
733 		printf("dpni_get_tx_data_offset() failed\n");
734 		goto err_data_offset;
735 	}
736 
737 	/* Warn in case TX data offset is not multiple of 64 bytes. */
738 	WARN_ON(priv->tx_data_offset % 64);
739 
740 	/* Accomodate SWA space. */
741 	priv->tx_data_offset += LDPAA_ETH_SWA_SIZE;
742 	debug("priv->tx_data_offset=%d\n", priv->tx_data_offset);
743 
744 	return 0;
745 
746 err_data_offset:
747 err_buf_layout:
748 err_get_attr:
749 	dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
750 err_open:
751 	return err;
752 }
753 
754 static int ldpaa_dpni_bind(struct ldpaa_eth_priv *priv)
755 {
756 	struct dpni_pools_cfg pools_params;
757 	struct dpni_tx_flow_cfg dflt_tx_flow;
758 	int err = 0;
759 
760 	pools_params.num_dpbp = 1;
761 	pools_params.pools[0].dpbp_id = (uint16_t)dflt_dpbp->dpbp_attr.id;
762 	pools_params.pools[0].buffer_size = LDPAA_ETH_RX_BUFFER_SIZE;
763 	err = dpni_set_pools(dflt_mc_io, MC_CMD_NO_FLAGS,
764 			     dflt_dpni->dpni_handle, &pools_params);
765 	if (err) {
766 		printf("dpni_set_pools() failed\n");
767 		return err;
768 	}
769 
770 	priv->tx_flow_id = DPNI_NEW_FLOW_ID;
771 	memset(&dflt_tx_flow, 0, sizeof(dflt_tx_flow));
772 
773 	dflt_tx_flow.options = DPNI_TX_FLOW_OPT_ONLY_TX_ERROR;
774 	dflt_tx_flow.conf_err_cfg.use_default_queue = 0;
775 	dflt_tx_flow.conf_err_cfg.errors_only = 1;
776 	err = dpni_set_tx_flow(dflt_mc_io, MC_CMD_NO_FLAGS,
777 			       dflt_dpni->dpni_handle, &priv->tx_flow_id,
778 			       &dflt_tx_flow);
779 	if (err) {
780 		printf("dpni_set_tx_flow() failed\n");
781 		return err;
782 	}
783 
784 	return 0;
785 }
786 
787 static int ldpaa_eth_netdev_init(struct eth_device *net_dev,
788 				 phy_interface_t enet_if)
789 {
790 	int err;
791 	struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
792 
793 	sprintf(net_dev->name, "DPMAC%d@%s", priv->dpmac_id,
794 		phy_interface_strings[enet_if]);
795 
796 	net_dev->iobase = 0;
797 	net_dev->init = ldpaa_eth_open;
798 	net_dev->halt = ldpaa_eth_stop;
799 	net_dev->send = ldpaa_eth_tx;
800 	net_dev->recv = ldpaa_eth_pull_dequeue_rx;
801 /*
802 	TODO: PHY MDIO information
803 	priv->bus = info->bus;
804 	priv->phyaddr = info->phy_addr;
805 	priv->enet_if = info->enet_if;
806 */
807 
808 	if (init_phy(net_dev))
809 		return 0;
810 
811 	err = eth_register(net_dev);
812 	if (err < 0) {
813 		printf("eth_register() = %d\n", err);
814 		return err;
815 	}
816 
817 	return 0;
818 }
819 
820 int ldpaa_eth_init(int dpmac_id, phy_interface_t enet_if)
821 {
822 	struct eth_device		*net_dev = NULL;
823 	struct ldpaa_eth_priv		*priv = NULL;
824 	int				err = 0;
825 
826 
827 	/* Net device */
828 	net_dev = (struct eth_device *)malloc(sizeof(struct eth_device));
829 	if (!net_dev) {
830 		printf("eth_device malloc() failed\n");
831 		return -ENOMEM;
832 	}
833 	memset(net_dev, 0, sizeof(struct eth_device));
834 
835 	/* alloc the ldpaa ethernet private struct */
836 	priv = (struct ldpaa_eth_priv *)malloc(sizeof(struct ldpaa_eth_priv));
837 	if (!priv) {
838 		printf("ldpaa_eth_priv malloc() failed\n");
839 		return -ENOMEM;
840 	}
841 	memset(priv, 0, sizeof(struct ldpaa_eth_priv));
842 
843 	net_dev->priv = (void *)priv;
844 	priv->net_dev = (struct eth_device *)net_dev;
845 	priv->dpmac_id = dpmac_id;
846 	debug("%s dpmac_id=%d\n", __func__, dpmac_id);
847 
848 	err = ldpaa_eth_netdev_init(net_dev, enet_if);
849 	if (err)
850 		goto err_netdev_init;
851 
852 	debug("ldpaa ethernet: Probed interface %s\n", net_dev->name);
853 	return 0;
854 
855 err_netdev_init:
856 	free(priv);
857 	net_dev->priv = NULL;
858 	free(net_dev);
859 
860 	return err;
861 }
862