1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright 2014-2016 Freescale Semiconductor, Inc.
4 * Copyright 2017 NXP
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 <fsl-mc/ldpaa_wriop.h>
18 #include "ldpaa_eth.h"
19
20 #ifdef CONFIG_PHYLIB
init_phy(struct eth_device * dev)21 static int init_phy(struct eth_device *dev)
22 {
23 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)dev->priv;
24 struct phy_device *phydev = NULL;
25 struct mii_dev *bus;
26
27 bus = wriop_get_mdio(priv->dpmac_id);
28 if (bus == NULL)
29 return 0;
30
31 phydev = phy_connect(bus, wriop_get_phy_address(priv->dpmac_id),
32 dev, wriop_get_enet_if(priv->dpmac_id));
33 if (!phydev) {
34 printf("Failed to connect\n");
35 return -1;
36 }
37
38 priv->phydev = phydev;
39
40 return phy_config(phydev);
41 }
42 #endif
43
44 #ifdef DEBUG
45
46 #define DPNI_STATS_PER_PAGE 6
47
48 static const char *dpni_statistics[][DPNI_STATS_PER_PAGE] = {
49 {
50 "DPNI_CNT_ING_ALL_FRAMES",
51 "DPNI_CNT_ING_ALL_BYTES",
52 "DPNI_CNT_ING_MCAST_FRAMES",
53 "DPNI_CNT_ING_MCAST_BYTES",
54 "DPNI_CNT_ING_BCAST_FRAMES",
55 "DPNI_CNT_ING_BCAST_BYTES",
56 }, {
57 "DPNI_CNT_EGR_ALL_FRAMES",
58 "DPNI_CNT_EGR_ALL_BYTES",
59 "DPNI_CNT_EGR_MCAST_FRAMES",
60 "DPNI_CNT_EGR_MCAST_BYTES",
61 "DPNI_CNT_EGR_BCAST_FRAMES",
62 "DPNI_CNT_EGR_BCAST_BYTES",
63 }, {
64 "DPNI_CNT_ING_FILTERED_FRAMES",
65 "DPNI_CNT_ING_DISCARDED_FRAMES",
66 "DPNI_CNT_ING_NOBUFFER_DISCARDS",
67 "DPNI_CNT_EGR_DISCARDED_FRAMES",
68 "DPNI_CNT_EGR_CNF_FRAMES",
69 ""
70 },
71 };
72
print_dpni_stats(const char * strings[],struct dpni_statistics dpni_stats)73 static void print_dpni_stats(const char *strings[],
74 struct dpni_statistics dpni_stats)
75 {
76 uint64_t *stat;
77 int i;
78
79 stat = (uint64_t *)&dpni_stats;
80 for (i = 0; i < DPNI_STATS_PER_PAGE; i++) {
81 if (strcmp(strings[i], "\0") == 0)
82 break;
83 printf("%s= %llu\n", strings[i], *stat);
84 stat++;
85 }
86 }
87
ldpaa_eth_get_dpni_counter(void)88 static void ldpaa_eth_get_dpni_counter(void)
89 {
90 int err = 0;
91 unsigned int page = 0;
92 struct dpni_statistics dpni_stats;
93
94 printf("DPNI counters ..\n");
95 for (page = 0; page < 3; page++) {
96 err = dpni_get_statistics(dflt_mc_io, MC_CMD_NO_FLAGS,
97 dflt_dpni->dpni_handle, page,
98 &dpni_stats);
99 if (err < 0) {
100 printf("dpni_get_statistics: failed:");
101 printf("%d for page[%d]\n", err, page);
102 return;
103 }
104 print_dpni_stats(dpni_statistics[page], dpni_stats);
105 }
106 }
107
ldpaa_eth_get_dpmac_counter(struct eth_device * net_dev)108 static void ldpaa_eth_get_dpmac_counter(struct eth_device *net_dev)
109 {
110 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
111 int err = 0;
112 u64 value;
113
114 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
115 priv->dpmac_handle,
116 DPMAC_CNT_ING_BYTE,
117 &value);
118 if (err < 0) {
119 printf("dpmac_get_counter: DPMAC_CNT_ING_BYTE failed\n");
120 return;
121 }
122 printf("\nDPMAC counters ..\n");
123 printf("DPMAC_CNT_ING_BYTE=%lld\n", value);
124
125 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
126 priv->dpmac_handle,
127 DPMAC_CNT_ING_FRAME_DISCARD,
128 &value);
129 if (err < 0) {
130 printf("dpmac_get_counter: DPMAC_CNT_ING_FRAME_DISCARD failed\n");
131 return;
132 }
133 printf("DPMAC_CNT_ING_FRAME_DISCARD=%lld\n", value);
134
135 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
136 priv->dpmac_handle,
137 DPMAC_CNT_ING_ALIGN_ERR,
138 &value);
139 if (err < 0) {
140 printf("dpmac_get_counter: DPMAC_CNT_ING_ALIGN_ERR failed\n");
141 return;
142 }
143 printf("DPMAC_CNT_ING_ALIGN_ERR =%lld\n", value);
144
145 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
146 priv->dpmac_handle,
147 DPMAC_CNT_ING_BYTE,
148 &value);
149 if (err < 0) {
150 printf("dpmac_get_counter: DPMAC_CNT_ING_BYTE failed\n");
151 return;
152 }
153 printf("DPMAC_CNT_ING_BYTE=%lld\n", value);
154
155 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
156 priv->dpmac_handle,
157 DPMAC_CNT_ING_ERR_FRAME,
158 &value);
159 if (err < 0) {
160 printf("dpmac_get_counter: DPMAC_CNT_ING_ERR_FRAME failed\n");
161 return;
162 }
163 printf("DPMAC_CNT_ING_ERR_FRAME=%lld\n", value);
164
165 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
166 priv->dpmac_handle,
167 DPMAC_CNT_EGR_BYTE ,
168 &value);
169 if (err < 0) {
170 printf("dpmac_get_counter: DPMAC_CNT_EGR_BYTE failed\n");
171 return;
172 }
173 printf("DPMAC_CNT_EGR_BYTE =%lld\n", value);
174
175 err = dpmac_get_counter(dflt_mc_io, MC_CMD_NO_FLAGS,
176 priv->dpmac_handle,
177 DPMAC_CNT_EGR_ERR_FRAME ,
178 &value);
179 if (err < 0) {
180 printf("dpmac_get_counter: DPMAC_CNT_EGR_ERR_FRAME failed\n");
181 return;
182 }
183 printf("DPMAC_CNT_EGR_ERR_FRAME =%lld\n", value);
184 }
185 #endif
186
ldpaa_eth_rx(struct ldpaa_eth_priv * priv,const struct dpaa_fd * fd)187 static void ldpaa_eth_rx(struct ldpaa_eth_priv *priv,
188 const struct dpaa_fd *fd)
189 {
190 u64 fd_addr;
191 uint16_t fd_offset;
192 uint32_t fd_length;
193 struct ldpaa_fas *fas;
194 uint32_t status, err;
195 u32 timeo = (CONFIG_SYS_HZ * 2) / 1000;
196 u32 time_start;
197 struct qbman_release_desc releasedesc;
198 struct qbman_swp *swp = dflt_dpio->sw_portal;
199
200 fd_addr = ldpaa_fd_get_addr(fd);
201 fd_offset = ldpaa_fd_get_offset(fd);
202 fd_length = ldpaa_fd_get_len(fd);
203
204 debug("Rx frame:data addr=0x%p size=0x%x\n", (u64 *)fd_addr, fd_length);
205
206 if (fd->simple.frc & LDPAA_FD_FRC_FASV) {
207 /* Read the frame annotation status word and check for errors */
208 fas = (struct ldpaa_fas *)
209 ((uint8_t *)(fd_addr) +
210 dflt_dpni->buf_layout.private_data_size);
211 status = le32_to_cpu(fas->status);
212 if (status & LDPAA_ETH_RX_ERR_MASK) {
213 printf("Rx frame error(s): 0x%08x\n",
214 status & LDPAA_ETH_RX_ERR_MASK);
215 goto error;
216 } else if (status & LDPAA_ETH_RX_UNSUPP_MASK) {
217 printf("Unsupported feature in bitmask: 0x%08x\n",
218 status & LDPAA_ETH_RX_UNSUPP_MASK);
219 goto error;
220 }
221 }
222
223 debug("Rx frame: To Upper layer\n");
224 net_process_received_packet((uint8_t *)(fd_addr) + fd_offset,
225 fd_length);
226
227 error:
228 flush_dcache_range(fd_addr, fd_addr + LDPAA_ETH_RX_BUFFER_SIZE);
229 qbman_release_desc_clear(&releasedesc);
230 qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid);
231 time_start = get_timer(0);
232 do {
233 /* Release buffer into the QBMAN */
234 err = qbman_swp_release(swp, &releasedesc, &fd_addr, 1);
235 } while (get_timer(time_start) < timeo && err == -EBUSY);
236
237 if (err == -EBUSY)
238 printf("Rx frame: QBMAN buffer release fails\n");
239
240 return;
241 }
242
ldpaa_eth_pull_dequeue_rx(struct eth_device * dev)243 static int ldpaa_eth_pull_dequeue_rx(struct eth_device *dev)
244 {
245 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)dev->priv;
246 const struct ldpaa_dq *dq;
247 const struct dpaa_fd *fd;
248 int i = 5, err = 0, status;
249 u32 timeo = (CONFIG_SYS_HZ * 2) / 1000;
250 u32 time_start;
251 static struct qbman_pull_desc pulldesc;
252 struct qbman_swp *swp = dflt_dpio->sw_portal;
253
254 while (--i) {
255 qbman_pull_desc_clear(&pulldesc);
256 qbman_pull_desc_set_numframes(&pulldesc, 1);
257 qbman_pull_desc_set_fq(&pulldesc, priv->rx_dflt_fqid);
258
259 err = qbman_swp_pull(swp, &pulldesc);
260 if (err < 0) {
261 printf("Dequeue frames error:0x%08x\n", err);
262 continue;
263 }
264
265 time_start = get_timer(0);
266
267 do {
268 dq = qbman_swp_dqrr_next(swp);
269 } while (get_timer(time_start) < timeo && !dq);
270
271 if (dq) {
272 /* Check for valid frame. If not sent a consume
273 * confirmation to QBMAN otherwise give it to NADK
274 * application and then send consume confirmation to
275 * QBMAN.
276 */
277 status = (uint8_t)ldpaa_dq_flags(dq);
278 if ((status & LDPAA_DQ_STAT_VALIDFRAME) == 0) {
279 debug("Dequeue RX frames:");
280 debug("No frame delivered\n");
281
282 qbman_swp_dqrr_consume(swp, dq);
283 continue;
284 }
285
286 fd = ldpaa_dq_fd(dq);
287
288 /* Obtain FD and process it */
289 ldpaa_eth_rx(priv, fd);
290 qbman_swp_dqrr_consume(swp, dq);
291 break;
292 } else {
293 err = -ENODATA;
294 debug("No DQRR entries\n");
295 break;
296 }
297 }
298
299 return err;
300 }
301
ldpaa_eth_tx(struct eth_device * net_dev,void * buf,int len)302 static int ldpaa_eth_tx(struct eth_device *net_dev, void *buf, int len)
303 {
304 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
305 struct dpaa_fd fd;
306 u64 buffer_start;
307 int data_offset, err;
308 u32 timeo = (CONFIG_SYS_HZ * 10) / 1000;
309 u32 time_start;
310 struct qbman_swp *swp = dflt_dpio->sw_portal;
311 struct qbman_eq_desc ed;
312 struct qbman_release_desc releasedesc;
313
314 /* Setup the FD fields */
315 memset(&fd, 0, sizeof(fd));
316
317 data_offset = priv->tx_data_offset;
318
319 do {
320 err = qbman_swp_acquire(dflt_dpio->sw_portal,
321 dflt_dpbp->dpbp_attr.bpid,
322 &buffer_start, 1);
323 } while (err == -EBUSY);
324
325 if (err <= 0) {
326 printf("qbman_swp_acquire() failed\n");
327 return -ENOMEM;
328 }
329
330 debug("TX data: malloc buffer start=0x%p\n", (u64 *)buffer_start);
331
332 memcpy(((uint8_t *)(buffer_start) + data_offset), buf, len);
333
334 flush_dcache_range(buffer_start, buffer_start +
335 LDPAA_ETH_RX_BUFFER_SIZE);
336
337 ldpaa_fd_set_addr(&fd, (u64)buffer_start);
338 ldpaa_fd_set_offset(&fd, (uint16_t)(data_offset));
339 ldpaa_fd_set_bpid(&fd, dflt_dpbp->dpbp_attr.bpid);
340 ldpaa_fd_set_len(&fd, len);
341
342 fd.simple.ctrl = LDPAA_FD_CTRL_ASAL | LDPAA_FD_CTRL_PTA |
343 LDPAA_FD_CTRL_PTV1;
344
345 qbman_eq_desc_clear(&ed);
346 qbman_eq_desc_set_no_orp(&ed, 0);
347 qbman_eq_desc_set_qd(&ed, priv->tx_qdid, priv->tx_flow_id, 0);
348
349 time_start = get_timer(0);
350
351 while (get_timer(time_start) < timeo) {
352 err = qbman_swp_enqueue(swp, &ed,
353 (const struct qbman_fd *)(&fd));
354 if (err != -EBUSY)
355 break;
356 }
357
358 if (err < 0) {
359 printf("error enqueueing Tx frame\n");
360 goto error;
361 }
362
363 return err;
364
365 error:
366 qbman_release_desc_clear(&releasedesc);
367 qbman_release_desc_set_bpid(&releasedesc, dflt_dpbp->dpbp_attr.bpid);
368 time_start = get_timer(0);
369 do {
370 /* Release buffer into the QBMAN */
371 err = qbman_swp_release(swp, &releasedesc, &buffer_start, 1);
372 } while (get_timer(time_start) < timeo && err == -EBUSY);
373
374 if (err == -EBUSY)
375 printf("TX data: QBMAN buffer release fails\n");
376
377 return err;
378 }
379
ldpaa_eth_open(struct eth_device * net_dev,bd_t * bd)380 static int ldpaa_eth_open(struct eth_device *net_dev, bd_t *bd)
381 {
382 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
383 struct dpmac_link_state dpmac_link_state = { 0 };
384 #ifdef DEBUG
385 struct dpni_link_state link_state;
386 #endif
387 int err = 0;
388 struct mii_dev *bus;
389 phy_interface_t enet_if;
390 struct dpni_queue d_queue;
391
392 if (net_dev->state == ETH_STATE_ACTIVE)
393 return 0;
394
395 if (get_mc_boot_status() != 0) {
396 printf("ERROR (MC is not booted)\n");
397 return -ENODEV;
398 }
399
400 if (get_dpl_apply_status() == 0) {
401 printf("ERROR (DPL is deployed. No device available)\n");
402 return -ENODEV;
403 }
404
405 /* DPMAC initialization */
406 err = ldpaa_dpmac_setup(priv);
407 if (err < 0)
408 goto err_dpmac_setup;
409
410 #ifdef CONFIG_PHYLIB
411 if (priv->phydev) {
412 err = phy_startup(priv->phydev);
413 if (err) {
414 printf("%s: Could not initialize\n",
415 priv->phydev->dev->name);
416 goto err_dpamc_bind;
417 }
418 }
419 #else
420 priv->phydev = (struct phy_device *)malloc(sizeof(struct phy_device));
421 memset(priv->phydev, 0, sizeof(struct phy_device));
422
423 priv->phydev->speed = SPEED_1000;
424 priv->phydev->link = 1;
425 priv->phydev->duplex = DUPLEX_FULL;
426 #endif
427
428 bus = wriop_get_mdio(priv->dpmac_id);
429 enet_if = wriop_get_enet_if(priv->dpmac_id);
430 if ((bus == NULL) &&
431 (enet_if == PHY_INTERFACE_MODE_XGMII)) {
432 priv->phydev = (struct phy_device *)
433 malloc(sizeof(struct phy_device));
434 memset(priv->phydev, 0, sizeof(struct phy_device));
435
436 priv->phydev->speed = SPEED_10000;
437 priv->phydev->link = 1;
438 priv->phydev->duplex = DUPLEX_FULL;
439 }
440
441 if (!priv->phydev->link) {
442 printf("%s: No link.\n", priv->phydev->dev->name);
443 err = -1;
444 goto err_dpamc_bind;
445 }
446
447 /* DPMAC binding DPNI */
448 err = ldpaa_dpmac_bind(priv);
449 if (err)
450 goto err_dpamc_bind;
451
452 /* DPNI initialization */
453 err = ldpaa_dpni_setup(priv);
454 if (err < 0)
455 goto err_dpni_setup;
456
457 err = ldpaa_dpbp_setup();
458 if (err < 0)
459 goto err_dpbp_setup;
460
461 /* DPNI binding DPBP */
462 err = ldpaa_dpni_bind(priv);
463 if (err)
464 goto err_dpni_bind;
465
466 err = dpni_add_mac_addr(dflt_mc_io, MC_CMD_NO_FLAGS,
467 dflt_dpni->dpni_handle, net_dev->enetaddr);
468 if (err) {
469 printf("dpni_add_mac_addr() failed\n");
470 return err;
471 }
472
473 err = dpni_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
474 if (err < 0) {
475 printf("dpni_enable() failed\n");
476 return err;
477 }
478
479 dpmac_link_state.rate = priv->phydev->speed;
480
481 if (priv->phydev->autoneg == AUTONEG_DISABLE)
482 dpmac_link_state.options &= ~DPMAC_LINK_OPT_AUTONEG;
483 else
484 dpmac_link_state.options |= DPMAC_LINK_OPT_AUTONEG;
485
486 if (priv->phydev->duplex == DUPLEX_HALF)
487 dpmac_link_state.options |= DPMAC_LINK_OPT_HALF_DUPLEX;
488
489 dpmac_link_state.up = priv->phydev->link;
490
491 err = dpmac_set_link_state(dflt_mc_io, MC_CMD_NO_FLAGS,
492 priv->dpmac_handle, &dpmac_link_state);
493 if (err < 0) {
494 printf("dpmac_set_link_state() failed\n");
495 return err;
496 }
497
498 #ifdef DEBUG
499 printf("DPMAC link status: %d - ", dpmac_link_state.up);
500 dpmac_link_state.up == 0 ? printf("down\n") :
501 dpmac_link_state.up == 1 ? printf("up\n") : printf("error state\n");
502
503 err = dpni_get_link_state(dflt_mc_io, MC_CMD_NO_FLAGS,
504 dflt_dpni->dpni_handle, &link_state);
505 if (err < 0) {
506 printf("dpni_get_link_state() failed\n");
507 return err;
508 }
509
510 printf("DPNI link status: %d - ", link_state.up);
511 link_state.up == 0 ? printf("down\n") :
512 link_state.up == 1 ? printf("up\n") : printf("error state\n");
513 #endif
514
515 memset(&d_queue, 0, sizeof(struct dpni_queue));
516 err = dpni_get_queue(dflt_mc_io, MC_CMD_NO_FLAGS,
517 dflt_dpni->dpni_handle, DPNI_QUEUE_RX,
518 0, 0, &d_queue);
519 if (err) {
520 printf("dpni_get_queue failed\n");
521 goto err_get_queue;
522 }
523
524 priv->rx_dflt_fqid = d_queue.fqid;
525
526 err = dpni_get_qdid(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle,
527 &priv->tx_qdid);
528 if (err) {
529 printf("dpni_get_qdid() failed\n");
530 goto err_qdid;
531 }
532
533 return priv->phydev->link;
534
535 err_qdid:
536 err_get_queue:
537 dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
538 err_dpni_bind:
539 ldpaa_dpbp_free();
540 err_dpbp_setup:
541 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
542 err_dpni_setup:
543 err_dpamc_bind:
544 dpmac_close(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
545 dpmac_destroy(dflt_mc_io,
546 dflt_dprc_handle,
547 MC_CMD_NO_FLAGS, priv->dpmac_id);
548 err_dpmac_setup:
549 return err;
550 }
551
ldpaa_eth_stop(struct eth_device * net_dev)552 static void ldpaa_eth_stop(struct eth_device *net_dev)
553 {
554 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
555 int err = 0;
556 #ifdef CONFIG_PHYLIB
557 struct mii_dev *bus = wriop_get_mdio(priv->dpmac_id);
558 #endif
559
560 if ((net_dev->state == ETH_STATE_PASSIVE) ||
561 (net_dev->state == ETH_STATE_INIT))
562 return;
563
564 #ifdef DEBUG
565 ldpaa_eth_get_dpni_counter();
566 ldpaa_eth_get_dpmac_counter(net_dev);
567 #endif
568
569 err = dprc_disconnect(dflt_mc_io, MC_CMD_NO_FLAGS,
570 dflt_dprc_handle, &dpmac_endpoint);
571 if (err < 0)
572 printf("dprc_disconnect() failed dpmac_endpoint\n");
573
574 err = dpmac_close(dflt_mc_io, MC_CMD_NO_FLAGS, priv->dpmac_handle);
575 if (err < 0)
576 printf("dpmac_close() failed\n");
577
578 err = dpmac_destroy(dflt_mc_io,
579 dflt_dprc_handle,
580 MC_CMD_NO_FLAGS,
581 priv->dpmac_id);
582 if (err < 0)
583 printf("dpmac_destroy() failed\n");
584
585 /* Stop Tx and Rx traffic */
586 err = dpni_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
587 if (err < 0)
588 printf("dpni_disable() failed\n");
589
590 #ifdef CONFIG_PHYLIB
591 if (priv->phydev && bus != NULL)
592 phy_shutdown(priv->phydev);
593 else {
594 free(priv->phydev);
595 priv->phydev = NULL;
596 }
597 #endif
598
599 /* Free DPBP handle and reset. */
600 ldpaa_dpbp_free();
601
602 dpni_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
603 if (err < 0)
604 printf("dpni_reset() failed\n");
605
606 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
607 if (err < 0)
608 printf("dpni_close() failed\n");
609 }
610
ldpaa_dpbp_drain_cnt(int count)611 static void ldpaa_dpbp_drain_cnt(int count)
612 {
613 uint64_t buf_array[7];
614 void *addr;
615 int ret, i;
616
617 BUG_ON(count > 7);
618
619 do {
620 ret = qbman_swp_acquire(dflt_dpio->sw_portal,
621 dflt_dpbp->dpbp_attr.bpid,
622 buf_array, count);
623 if (ret < 0) {
624 printf("qbman_swp_acquire() failed\n");
625 return;
626 }
627 for (i = 0; i < ret; i++) {
628 addr = (void *)buf_array[i];
629 debug("Free: buffer addr =0x%p\n", addr);
630 free(addr);
631 }
632 } while (ret);
633 }
634
ldpaa_dpbp_drain(void)635 static void ldpaa_dpbp_drain(void)
636 {
637 int i;
638 for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7)
639 ldpaa_dpbp_drain_cnt(7);
640 }
641
ldpaa_bp_add_7(uint16_t bpid)642 static int ldpaa_bp_add_7(uint16_t bpid)
643 {
644 uint64_t buf_array[7];
645 u8 *addr;
646 int i;
647 struct qbman_release_desc rd;
648
649 for (i = 0; i < 7; i++) {
650 addr = memalign(LDPAA_ETH_BUF_ALIGN, LDPAA_ETH_RX_BUFFER_SIZE);
651 if (!addr) {
652 printf("addr allocation failed\n");
653 goto err_alloc;
654 }
655 memset(addr, 0x00, LDPAA_ETH_RX_BUFFER_SIZE);
656 flush_dcache_range((u64)addr,
657 (u64)(addr + LDPAA_ETH_RX_BUFFER_SIZE));
658
659 buf_array[i] = (uint64_t)addr;
660 debug("Release: buffer addr =0x%p\n", addr);
661 }
662
663 release_bufs:
664 /* In case the portal is busy, retry until successful.
665 * This function is guaranteed to succeed in a reasonable amount
666 * of time.
667 */
668
669 do {
670 mdelay(1);
671 qbman_release_desc_clear(&rd);
672 qbman_release_desc_set_bpid(&rd, bpid);
673 } while (qbman_swp_release(dflt_dpio->sw_portal, &rd, buf_array, i));
674
675 return i;
676
677 err_alloc:
678 if (i)
679 goto release_bufs;
680
681 return 0;
682 }
683
ldpaa_dpbp_seed(uint16_t bpid)684 static int ldpaa_dpbp_seed(uint16_t bpid)
685 {
686 int i;
687 int count;
688
689 for (i = 0; i < LDPAA_ETH_NUM_BUFS; i += 7) {
690 count = ldpaa_bp_add_7(bpid);
691 if (count < 7)
692 printf("Buffer Seed= %d\n", count);
693 }
694
695 return 0;
696 }
697
ldpaa_dpbp_setup(void)698 static int ldpaa_dpbp_setup(void)
699 {
700 int err;
701
702 err = dpbp_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_attr.id,
703 &dflt_dpbp->dpbp_handle);
704 if (err) {
705 printf("dpbp_open() failed\n");
706 goto err_open;
707 }
708
709 err = dpbp_enable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
710 if (err) {
711 printf("dpbp_enable() failed\n");
712 goto err_enable;
713 }
714
715 err = dpbp_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
716 dflt_dpbp->dpbp_handle,
717 &dflt_dpbp->dpbp_attr);
718 if (err) {
719 printf("dpbp_get_attributes() failed\n");
720 goto err_get_attr;
721 }
722
723 err = ldpaa_dpbp_seed(dflt_dpbp->dpbp_attr.bpid);
724
725 if (err) {
726 printf("Buffer seeding failed for DPBP %d (bpid=%d)\n",
727 dflt_dpbp->dpbp_attr.id, dflt_dpbp->dpbp_attr.bpid);
728 goto err_seed;
729 }
730
731 return 0;
732
733 err_seed:
734 err_get_attr:
735 dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
736 err_enable:
737 dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
738 err_open:
739 return err;
740 }
741
ldpaa_dpbp_free(void)742 static void ldpaa_dpbp_free(void)
743 {
744 ldpaa_dpbp_drain();
745 dpbp_disable(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
746 dpbp_reset(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
747 dpbp_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpbp->dpbp_handle);
748 }
749
ldpaa_dpmac_version_check(struct fsl_mc_io * mc_io,struct ldpaa_eth_priv * priv)750 static int ldpaa_dpmac_version_check(struct fsl_mc_io *mc_io,
751 struct ldpaa_eth_priv *priv)
752 {
753 int error;
754 uint16_t major_ver, minor_ver;
755
756 error = dpmac_get_api_version(dflt_mc_io, 0,
757 &major_ver,
758 &minor_ver);
759 if ((major_ver < DPMAC_VER_MAJOR) ||
760 (major_ver == DPMAC_VER_MAJOR && minor_ver < DPMAC_VER_MINOR)) {
761 printf("DPMAC version mismatch found %u.%u,",
762 major_ver, minor_ver);
763 printf("supported version is %u.%u\n",
764 DPMAC_VER_MAJOR, DPMAC_VER_MINOR);
765 return error;
766 }
767
768 return error;
769 }
770
ldpaa_dpmac_setup(struct ldpaa_eth_priv * priv)771 static int ldpaa_dpmac_setup(struct ldpaa_eth_priv *priv)
772 {
773 int err = 0;
774 struct dpmac_cfg dpmac_cfg;
775
776 dpmac_cfg.mac_id = priv->dpmac_id;
777
778 err = dpmac_create(dflt_mc_io,
779 dflt_dprc_handle,
780 MC_CMD_NO_FLAGS, &dpmac_cfg,
781 &priv->dpmac_id);
782 if (err)
783 printf("dpmac_create() failed\n");
784
785 err = ldpaa_dpmac_version_check(dflt_mc_io, priv);
786 if (err < 0) {
787 printf("ldpaa_dpmac_version_check() failed: %d\n", err);
788 goto err_version_check;
789 }
790
791 err = dpmac_open(dflt_mc_io,
792 MC_CMD_NO_FLAGS,
793 priv->dpmac_id,
794 &priv->dpmac_handle);
795 if (err < 0) {
796 printf("dpmac_open() failed: %d\n", err);
797 goto err_open;
798 }
799
800 return err;
801
802 err_open:
803 err_version_check:
804 dpmac_destroy(dflt_mc_io,
805 dflt_dprc_handle,
806 MC_CMD_NO_FLAGS, priv->dpmac_id);
807
808 return err;
809 }
810
ldpaa_dpmac_bind(struct ldpaa_eth_priv * priv)811 static int ldpaa_dpmac_bind(struct ldpaa_eth_priv *priv)
812 {
813 int err = 0;
814 struct dprc_connection_cfg dprc_connection_cfg = {
815 /* If both rates are zero the connection */
816 /* will be configured in "best effort" mode. */
817 .committed_rate = 0,
818 .max_rate = 0
819 };
820
821 #ifdef DEBUG
822 struct dprc_endpoint dbg_endpoint;
823 int state = 0;
824 #endif
825
826 memset(&dpmac_endpoint, 0, sizeof(struct dprc_endpoint));
827 strcpy(dpmac_endpoint.type, "dpmac");
828 dpmac_endpoint.id = priv->dpmac_id;
829
830 memset(&dpni_endpoint, 0, sizeof(struct dprc_endpoint));
831 strcpy(dpni_endpoint.type, "dpni");
832 dpni_endpoint.id = dflt_dpni->dpni_id;
833
834 err = dprc_connect(dflt_mc_io, MC_CMD_NO_FLAGS,
835 dflt_dprc_handle,
836 &dpmac_endpoint,
837 &dpni_endpoint,
838 &dprc_connection_cfg);
839 if (err)
840 printf("dprc_connect() failed\n");
841
842 #ifdef DEBUG
843 err = dprc_get_connection(dflt_mc_io, MC_CMD_NO_FLAGS,
844 dflt_dprc_handle, &dpni_endpoint,
845 &dbg_endpoint, &state);
846 printf("%s, DPMAC Type= %s\n", __func__, dbg_endpoint.type);
847 printf("%s, DPMAC ID= %d\n", __func__, dbg_endpoint.id);
848 printf("%s, DPMAC State= %d\n", __func__, state);
849
850 memset(&dbg_endpoint, 0, sizeof(struct dprc_endpoint));
851 err = dprc_get_connection(dflt_mc_io, MC_CMD_NO_FLAGS,
852 dflt_dprc_handle, &dpmac_endpoint,
853 &dbg_endpoint, &state);
854 printf("%s, DPNI Type= %s\n", __func__, dbg_endpoint.type);
855 printf("%s, DPNI ID= %d\n", __func__, dbg_endpoint.id);
856 printf("%s, DPNI State= %d\n", __func__, state);
857 #endif
858 return err;
859 }
860
ldpaa_dpni_setup(struct ldpaa_eth_priv * priv)861 static int ldpaa_dpni_setup(struct ldpaa_eth_priv *priv)
862 {
863 int err;
864
865 /* and get a handle for the DPNI this interface is associate with */
866 err = dpni_open(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_id,
867 &dflt_dpni->dpni_handle);
868 if (err) {
869 printf("dpni_open() failed\n");
870 goto err_open;
871 }
872 err = dpni_get_attributes(dflt_mc_io, MC_CMD_NO_FLAGS,
873 dflt_dpni->dpni_handle,
874 &dflt_dpni->dpni_attrs);
875 if (err) {
876 printf("dpni_get_attributes() failed (err=%d)\n", err);
877 goto err_get_attr;
878 }
879
880 /* Configure our buffers' layout */
881 dflt_dpni->buf_layout.options = DPNI_BUF_LAYOUT_OPT_PARSER_RESULT |
882 DPNI_BUF_LAYOUT_OPT_FRAME_STATUS |
883 DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE |
884 DPNI_BUF_LAYOUT_OPT_DATA_ALIGN;
885 dflt_dpni->buf_layout.pass_parser_result = true;
886 dflt_dpni->buf_layout.pass_frame_status = true;
887 dflt_dpni->buf_layout.private_data_size = LDPAA_ETH_SWA_SIZE;
888 /* HW erratum mandates data alignment in multiples of 256 */
889 dflt_dpni->buf_layout.data_align = LDPAA_ETH_BUF_ALIGN;
890
891 /* ...rx, ... */
892 err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
893 dflt_dpni->dpni_handle,
894 &dflt_dpni->buf_layout, DPNI_QUEUE_RX);
895 if (err) {
896 printf("dpni_set_buffer_layout() failed");
897 goto err_buf_layout;
898 }
899
900 /* ... tx, ... */
901 /* remove Rx-only options */
902 dflt_dpni->buf_layout.options &= ~(DPNI_BUF_LAYOUT_OPT_DATA_ALIGN |
903 DPNI_BUF_LAYOUT_OPT_PARSER_RESULT);
904 err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
905 dflt_dpni->dpni_handle,
906 &dflt_dpni->buf_layout, DPNI_QUEUE_TX);
907 if (err) {
908 printf("dpni_set_buffer_layout() failed");
909 goto err_buf_layout;
910 }
911
912 /* ... tx-confirm. */
913 dflt_dpni->buf_layout.options &= ~DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE;
914 err = dpni_set_buffer_layout(dflt_mc_io, MC_CMD_NO_FLAGS,
915 dflt_dpni->dpni_handle,
916 &dflt_dpni->buf_layout,
917 DPNI_QUEUE_TX_CONFIRM);
918 if (err) {
919 printf("dpni_set_buffer_layout() failed");
920 goto err_buf_layout;
921 }
922
923 /* Now that we've set our tx buffer layout, retrieve the minimum
924 * required tx data offset.
925 */
926 err = dpni_get_tx_data_offset(dflt_mc_io, MC_CMD_NO_FLAGS,
927 dflt_dpni->dpni_handle,
928 &priv->tx_data_offset);
929 if (err) {
930 printf("dpni_get_tx_data_offset() failed\n");
931 goto err_data_offset;
932 }
933
934 /* Warn in case TX data offset is not multiple of 64 bytes. */
935 WARN_ON(priv->tx_data_offset % 64);
936
937 /* Accomodate SWA space. */
938 priv->tx_data_offset += LDPAA_ETH_SWA_SIZE;
939 debug("priv->tx_data_offset=%d\n", priv->tx_data_offset);
940
941 return 0;
942
943 err_data_offset:
944 err_buf_layout:
945 err_get_attr:
946 dpni_close(dflt_mc_io, MC_CMD_NO_FLAGS, dflt_dpni->dpni_handle);
947 err_open:
948 return err;
949 }
950
ldpaa_dpni_bind(struct ldpaa_eth_priv * priv)951 static int ldpaa_dpni_bind(struct ldpaa_eth_priv *priv)
952 {
953 struct dpni_pools_cfg pools_params;
954 struct dpni_queue tx_queue;
955 int err = 0;
956
957 memset(&pools_params, 0, sizeof(pools_params));
958 pools_params.num_dpbp = 1;
959 pools_params.pools[0].dpbp_id = (uint16_t)dflt_dpbp->dpbp_attr.id;
960 pools_params.pools[0].buffer_size = LDPAA_ETH_RX_BUFFER_SIZE;
961 err = dpni_set_pools(dflt_mc_io, MC_CMD_NO_FLAGS,
962 dflt_dpni->dpni_handle, &pools_params);
963 if (err) {
964 printf("dpni_set_pools() failed\n");
965 return err;
966 }
967
968 memset(&tx_queue, 0, sizeof(struct dpni_queue));
969
970 err = dpni_set_queue(dflt_mc_io, MC_CMD_NO_FLAGS,
971 dflt_dpni->dpni_handle,
972 DPNI_QUEUE_TX, 0, 0, &tx_queue);
973
974 if (err) {
975 printf("dpni_set_queue() failed\n");
976 return err;
977 }
978
979 err = dpni_set_tx_confirmation_mode(dflt_mc_io, MC_CMD_NO_FLAGS,
980 dflt_dpni->dpni_handle,
981 DPNI_CONF_DISABLE);
982 if (err) {
983 printf("dpni_set_tx_confirmation_mode() failed\n");
984 return err;
985 }
986
987 return 0;
988 }
989
ldpaa_eth_netdev_init(struct eth_device * net_dev,phy_interface_t enet_if)990 static int ldpaa_eth_netdev_init(struct eth_device *net_dev,
991 phy_interface_t enet_if)
992 {
993 int err;
994 struct ldpaa_eth_priv *priv = (struct ldpaa_eth_priv *)net_dev->priv;
995
996 sprintf(net_dev->name, "DPMAC%d@%s", priv->dpmac_id,
997 phy_interface_strings[enet_if]);
998
999 net_dev->iobase = 0;
1000 net_dev->init = ldpaa_eth_open;
1001 net_dev->halt = ldpaa_eth_stop;
1002 net_dev->send = ldpaa_eth_tx;
1003 net_dev->recv = ldpaa_eth_pull_dequeue_rx;
1004
1005 #ifdef CONFIG_PHYLIB
1006 err = init_phy(net_dev);
1007 if (err < 0)
1008 return err;
1009 #endif
1010
1011 err = eth_register(net_dev);
1012 if (err < 0) {
1013 printf("eth_register() = %d\n", err);
1014 return err;
1015 }
1016
1017 return 0;
1018 }
1019
ldpaa_eth_init(int dpmac_id,phy_interface_t enet_if)1020 int ldpaa_eth_init(int dpmac_id, phy_interface_t enet_if)
1021 {
1022 struct eth_device *net_dev = NULL;
1023 struct ldpaa_eth_priv *priv = NULL;
1024 int err = 0;
1025
1026 /* Net device */
1027 net_dev = (struct eth_device *)malloc(sizeof(struct eth_device));
1028 if (!net_dev) {
1029 printf("eth_device malloc() failed\n");
1030 return -ENOMEM;
1031 }
1032 memset(net_dev, 0, sizeof(struct eth_device));
1033
1034 /* alloc the ldpaa ethernet private struct */
1035 priv = (struct ldpaa_eth_priv *)malloc(sizeof(struct ldpaa_eth_priv));
1036 if (!priv) {
1037 printf("ldpaa_eth_priv malloc() failed\n");
1038 return -ENOMEM;
1039 }
1040 memset(priv, 0, sizeof(struct ldpaa_eth_priv));
1041
1042 net_dev->priv = (void *)priv;
1043 priv->net_dev = (struct eth_device *)net_dev;
1044 priv->dpmac_id = dpmac_id;
1045 debug("%s dpmac_id=%d\n", __func__, dpmac_id);
1046
1047 err = ldpaa_eth_netdev_init(net_dev, enet_if);
1048 if (err)
1049 goto err_netdev_init;
1050
1051 debug("ldpaa ethernet: Probed interface %s\n", net_dev->name);
1052 return 0;
1053
1054 err_netdev_init:
1055 free(priv);
1056 net_dev->priv = NULL;
1057 free(net_dev);
1058
1059 return err;
1060 }
1061