1
2
3
4
5
6
7#include <common.h>
8#include <log.h>
9#include <part.h>
10#include <asm/io.h>
11#ifdef CONFIG_DM_ETH
12#include <dm.h>
13#include <dm/ofnode.h>
14#include <linux/compat.h>
15#include <phy_interface.h>
16#endif
17#include <malloc.h>
18#include <net.h>
19#include <hwconfig.h>
20#include <fm_eth.h>
21#include <fsl_mdio.h>
22#include <miiphy.h>
23#include <phy.h>
24#include <fsl_dtsec.h>
25#include <fsl_tgec.h>
26#include <fsl_memac.h>
27#include <linux/delay.h>
28
29#include "fm.h"
30
31#ifndef CONFIG_DM_ETH
32static struct eth_device *devlist[NUM_FM_PORTS];
33static int num_controllers;
34#endif
35
36#if defined(CONFIG_MII) || defined(CONFIG_CMD_MII) && !defined(BITBANGMII)
37
38#define TBIANA_SETTINGS (TBIANA_ASYMMETRIC_PAUSE | TBIANA_SYMMETRIC_PAUSE | \
39 TBIANA_FULL_DUPLEX)
40
41#define TBIANA_SGMII_ACK 0x4001
42
43#define TBICR_SETTINGS (TBICR_ANEG_ENABLE | TBICR_RESTART_ANEG | \
44 TBICR_FULL_DUPLEX | TBICR_SPEED1_SET)
45
46
47static void dtsec_configure_serdes(struct fm_eth *priv)
48{
49#ifdef CONFIG_SYS_FMAN_V3
50 u32 value;
51 struct mii_dev bus;
52 bool sgmii_2500 = (priv->enet_if ==
53 PHY_INTERFACE_MODE_2500BASEX) ? true : false;
54 int i = 0, j;
55
56#ifndef CONFIG_DM_ETH
57 bus.priv = priv->mac->phyregs;
58#else
59 bus.priv = priv->pcs_mdio;
60 bus.read = memac_mdio_read;
61 bus.write = memac_mdio_write;
62 bus.reset = memac_mdio_reset;
63#endif
64
65qsgmii_loop:
66
67 if (sgmii_2500)
68 value = PHY_SGMII_CR_PHY_RESET |
69 PHY_SGMII_IF_SPEED_GIGABIT |
70 PHY_SGMII_IF_MODE_SGMII;
71 else
72 value = PHY_SGMII_IF_MODE_SGMII | PHY_SGMII_IF_MODE_AN;
73
74 for (j = 0; j <= 3; j++)
75 debug("dump PCS reg %#x: %#x\n", j,
76 memac_mdio_read(&bus, i, MDIO_DEVAD_NONE, j));
77
78 memac_mdio_write(&bus, i, MDIO_DEVAD_NONE, 0x14, value);
79
80
81 value = PHY_SGMII_DEV_ABILITY_SGMII;
82 memac_mdio_write(&bus, i, MDIO_DEVAD_NONE, 0x4, value);
83
84 if (sgmii_2500) {
85
86
87
88
89 memac_mdio_write(&bus, i, MDIO_DEVAD_NONE, 0x13, 0x0007);
90 memac_mdio_write(&bus, i, MDIO_DEVAD_NONE, 0x12, 0xa120);
91 } else {
92
93
94
95
96 memac_mdio_write(&bus, i, MDIO_DEVAD_NONE, 0x13, 0x0003);
97 memac_mdio_write(&bus, i, MDIO_DEVAD_NONE, 0x12, 0x0d40);
98 }
99
100
101 value = PHY_SGMII_CR_DEF_VAL | PHY_SGMII_CR_RESET_AN;
102 memac_mdio_write(&bus, i, MDIO_DEVAD_NONE, 0, value);
103
104 if ((priv->enet_if == PHY_INTERFACE_MODE_QSGMII) && (i < 3)) {
105 i++;
106 goto qsgmii_loop;
107 }
108#else
109 struct dtsec *regs = priv->mac->base;
110 struct tsec_mii_mng *phyregs = priv->mac->phyregs;
111
112
113
114
115
116 tsec_local_mdio_write(phyregs, in_be32(®s->tbipa), 0, TBI_TBICON,
117 TBICON_CLK_SELECT);
118 tsec_local_mdio_write(phyregs, in_be32(®s->tbipa), 0, TBI_ANA,
119 TBIANA_SGMII_ACK);
120 tsec_local_mdio_write(phyregs, in_be32(®s->tbipa), 0,
121 TBI_CR, TBICR_SETTINGS);
122#endif
123}
124
125static void dtsec_init_phy(struct fm_eth *fm_eth)
126{
127#ifndef CONFIG_SYS_FMAN_V3
128 struct dtsec *regs = (struct dtsec *)CONFIG_SYS_FSL_FM1_DTSEC1_ADDR;
129
130
131 out_be32(®s->tbipa, CONFIG_SYS_TBIPA_VALUE);
132#endif
133
134 if (fm_eth->enet_if == PHY_INTERFACE_MODE_SGMII ||
135 fm_eth->enet_if == PHY_INTERFACE_MODE_QSGMII ||
136 fm_eth->enet_if == PHY_INTERFACE_MODE_2500BASEX)
137 dtsec_configure_serdes(fm_eth);
138}
139
140#ifndef CONFIG_DM_ETH
141#ifdef CONFIG_PHYLIB
142static int tgec_is_fibre(struct fm_eth *fm)
143{
144 char phyopt[20];
145
146 sprintf(phyopt, "fsl_fm%d_xaui_phy", fm->fm_index + 1);
147
148 return hwconfig_arg_cmp(phyopt, "xfi");
149}
150#endif
151#endif
152#endif
153
154static u16 muram_readw(u16 *addr)
155{
156 ulong base = (ulong)addr & ~0x3UL;
157 u32 val32 = in_be32((void *)base);
158 int byte_pos;
159 u16 ret;
160
161 byte_pos = (ulong)addr & 0x3UL;
162 if (byte_pos)
163 ret = (u16)(val32 & 0x0000ffff);
164 else
165 ret = (u16)((val32 & 0xffff0000) >> 16);
166
167 return ret;
168}
169
170static void muram_writew(u16 *addr, u16 val)
171{
172 ulong base = (ulong)addr & ~0x3UL;
173 u32 org32 = in_be32((void *)base);
174 u32 val32;
175 int byte_pos;
176
177 byte_pos = (ulong)addr & 0x3UL;
178 if (byte_pos)
179 val32 = (org32 & 0xffff0000) | val;
180 else
181 val32 = (org32 & 0x0000ffff) | ((u32)val << 16);
182
183 out_be32((void *)base, val32);
184}
185
186static void bmi_rx_port_disable(struct fm_bmi_rx_port *rx_port)
187{
188 int timeout = 1000000;
189
190 clrbits_be32(&rx_port->fmbm_rcfg, FMBM_RCFG_EN);
191
192
193 while ((in_be32(&rx_port->fmbm_rst) & FMBM_RST_BSY) && timeout--)
194 ;
195 if (!timeout)
196 printf("%s - timeout\n", __func__);
197}
198
199static void bmi_rx_port_init(struct fm_bmi_rx_port *rx_port)
200{
201
202 out_be32(&rx_port->fmbm_rcfg, FMBM_RCFG_IM);
203
204 out_be32(&rx_port->fmbm_rim, 0);
205
206 out_be32(&rx_port->fmbm_rfne, NIA_ENG_RISC | NIA_RISC_AC_IM_RX);
207
208 clrbits_be32(&rx_port->fmbm_rfca, FMBM_RFCA_ORDER | FMBM_RFCA_MR_MASK);
209 setbits_be32(&rx_port->fmbm_rfca, FMBM_RFCA_MR(4));
210
211 out_be32(&rx_port->fmbm_rstc, FMBM_RSTC_EN);
212
213 out_be32(&rx_port->fmbm_rpc, 0);
214}
215
216static void bmi_tx_port_disable(struct fm_bmi_tx_port *tx_port)
217{
218 int timeout = 1000000;
219
220 clrbits_be32(&tx_port->fmbm_tcfg, FMBM_TCFG_EN);
221
222
223 while ((in_be32(&tx_port->fmbm_tst) & FMBM_TST_BSY) && timeout--)
224 ;
225 if (!timeout)
226 printf("%s - timeout\n", __func__);
227}
228
229static void bmi_tx_port_init(struct fm_bmi_tx_port *tx_port)
230{
231
232 out_be32(&tx_port->fmbm_tcfg, FMBM_TCFG_IM);
233
234 out_be32(&tx_port->fmbm_tfne, NIA_ENG_RISC | NIA_RISC_AC_IM_TX);
235 out_be32(&tx_port->fmbm_tfene, NIA_ENG_RISC | NIA_RISC_AC_IM_TX);
236
237 clrbits_be32(&tx_port->fmbm_tfca, FMBM_TFCA_ORDER | FMBM_TFCA_MR_MASK);
238 setbits_be32(&tx_port->fmbm_tfca, FMBM_TFCA_MR(4));
239
240 out_be32(&tx_port->fmbm_tstc, FMBM_TSTC_EN);
241
242 out_be32(&tx_port->fmbm_tpc, 0);
243}
244
245static int fm_eth_rx_port_parameter_init(struct fm_eth *fm_eth)
246{
247 struct fm_port_global_pram *pram;
248 u32 pram_page_offset;
249 void *rx_bd_ring_base;
250 void *rx_buf_pool;
251 u32 bd_ring_base_lo, bd_ring_base_hi;
252 u32 buf_lo, buf_hi;
253 struct fm_port_bd *rxbd;
254 struct fm_port_qd *rxqd;
255 struct fm_bmi_rx_port *bmi_rx_port = fm_eth->rx_port;
256 int i;
257
258
259 pram = (struct fm_port_global_pram *)fm_muram_alloc(fm_eth->fm_index,
260 FM_PRAM_SIZE, FM_PRAM_ALIGN);
261 if (!pram) {
262 printf("%s: No muram for Rx global parameter\n", __func__);
263 return -ENOMEM;
264 }
265
266 fm_eth->rx_pram = pram;
267
268
269 pram_page_offset = (void *)pram - fm_muram_base(fm_eth->fm_index);
270
271
272 out_be32(&pram->mode, PRAM_MODE_GLOBAL);
273
274
275 out_be32(&pram->rxqd_ptr, pram_page_offset + 0x20);
276
277
278 muram_writew(&pram->mrblr, MAX_RXBUF_LOG2);
279
280
281 rx_bd_ring_base = malloc(sizeof(struct fm_port_bd)
282 * RX_BD_RING_SIZE);
283 if (!rx_bd_ring_base)
284 return -ENOMEM;
285
286 memset(rx_bd_ring_base, 0, sizeof(struct fm_port_bd)
287 * RX_BD_RING_SIZE);
288
289
290 rx_buf_pool = malloc(MAX_RXBUF_LEN * RX_BD_RING_SIZE);
291 if (!rx_buf_pool) {
292 free(rx_bd_ring_base);
293 return -ENOMEM;
294 }
295
296 memset(rx_buf_pool, 0, MAX_RXBUF_LEN * RX_BD_RING_SIZE);
297 debug("%s: rx_buf_pool = %p\n", __func__, rx_buf_pool);
298
299
300 fm_eth->rx_bd_ring = rx_bd_ring_base;
301 fm_eth->cur_rxbd = rx_bd_ring_base;
302 fm_eth->rx_buf = rx_buf_pool;
303
304
305 rxbd = (struct fm_port_bd *)rx_bd_ring_base;
306 for (i = 0; i < RX_BD_RING_SIZE; i++) {
307 muram_writew(&rxbd->status, RxBD_EMPTY);
308 muram_writew(&rxbd->len, 0);
309 buf_hi = upper_32_bits(virt_to_phys(rx_buf_pool +
310 i * MAX_RXBUF_LEN));
311 buf_lo = lower_32_bits(virt_to_phys(rx_buf_pool +
312 i * MAX_RXBUF_LEN));
313 muram_writew(&rxbd->buf_ptr_hi, (u16)buf_hi);
314 out_be32(&rxbd->buf_ptr_lo, buf_lo);
315 rxbd++;
316 }
317
318
319 rxqd = &pram->rxqd;
320 muram_writew(&rxqd->gen, 0);
321 bd_ring_base_hi = upper_32_bits(virt_to_phys(rx_bd_ring_base));
322 bd_ring_base_lo = lower_32_bits(virt_to_phys(rx_bd_ring_base));
323 muram_writew(&rxqd->bd_ring_base_hi, (u16)bd_ring_base_hi);
324 out_be32(&rxqd->bd_ring_base_lo, bd_ring_base_lo);
325 muram_writew(&rxqd->bd_ring_size, sizeof(struct fm_port_bd)
326 * RX_BD_RING_SIZE);
327 muram_writew(&rxqd->offset_in, 0);
328 muram_writew(&rxqd->offset_out, 0);
329
330
331 out_be32(&bmi_rx_port->fmbm_rfqid, pram_page_offset);
332
333 return 0;
334}
335
336static int fm_eth_tx_port_parameter_init(struct fm_eth *fm_eth)
337{
338 struct fm_port_global_pram *pram;
339 u32 pram_page_offset;
340 void *tx_bd_ring_base;
341 u32 bd_ring_base_lo, bd_ring_base_hi;
342 struct fm_port_bd *txbd;
343 struct fm_port_qd *txqd;
344 struct fm_bmi_tx_port *bmi_tx_port = fm_eth->tx_port;
345 int i;
346
347
348 pram = (struct fm_port_global_pram *)fm_muram_alloc(fm_eth->fm_index,
349 FM_PRAM_SIZE, FM_PRAM_ALIGN);
350 if (!pram) {
351 printf("%s: No muram for Tx global parameter\n", __func__);
352 return -ENOMEM;
353 }
354 fm_eth->tx_pram = pram;
355
356
357 pram_page_offset = (void *)pram - fm_muram_base(fm_eth->fm_index);
358
359
360 out_be32(&pram->mode, PRAM_MODE_GLOBAL);
361
362
363 out_be32(&pram->txqd_ptr, pram_page_offset + 0x40);
364
365
366 tx_bd_ring_base = malloc(sizeof(struct fm_port_bd)
367 * TX_BD_RING_SIZE);
368 if (!tx_bd_ring_base)
369 return -ENOMEM;
370
371 memset(tx_bd_ring_base, 0, sizeof(struct fm_port_bd)
372 * TX_BD_RING_SIZE);
373
374 fm_eth->tx_bd_ring = tx_bd_ring_base;
375 fm_eth->cur_txbd = tx_bd_ring_base;
376
377
378 txbd = (struct fm_port_bd *)tx_bd_ring_base;
379 for (i = 0; i < TX_BD_RING_SIZE; i++) {
380 muram_writew(&txbd->status, TxBD_LAST);
381 muram_writew(&txbd->len, 0);
382 muram_writew(&txbd->buf_ptr_hi, 0);
383 out_be32(&txbd->buf_ptr_lo, 0);
384 txbd++;
385 }
386
387
388 txqd = &pram->txqd;
389 bd_ring_base_hi = upper_32_bits(virt_to_phys(tx_bd_ring_base));
390 bd_ring_base_lo = lower_32_bits(virt_to_phys(tx_bd_ring_base));
391 muram_writew(&txqd->bd_ring_base_hi, (u16)bd_ring_base_hi);
392 out_be32(&txqd->bd_ring_base_lo, bd_ring_base_lo);
393 muram_writew(&txqd->bd_ring_size, sizeof(struct fm_port_bd)
394 * TX_BD_RING_SIZE);
395 muram_writew(&txqd->offset_in, 0);
396 muram_writew(&txqd->offset_out, 0);
397
398
399 out_be32(&bmi_tx_port->fmbm_tcfqid, pram_page_offset);
400
401 return 0;
402}
403
404static int fm_eth_init(struct fm_eth *fm_eth)
405{
406 int ret;
407
408 ret = fm_eth_rx_port_parameter_init(fm_eth);
409 if (ret)
410 return ret;
411
412 ret = fm_eth_tx_port_parameter_init(fm_eth);
413 if (ret)
414 return ret;
415
416 return 0;
417}
418
419static int fm_eth_startup(struct fm_eth *fm_eth)
420{
421 struct fsl_enet_mac *mac;
422 int ret;
423
424 mac = fm_eth->mac;
425
426
427 ret = fm_eth_init(fm_eth);
428 if (ret)
429 return ret;
430
431 mac->init_mac(mac);
432
433
434 if (((fm_eth->enet_if == PHY_INTERFACE_MODE_SGMII) ||
435 (fm_eth->enet_if == PHY_INTERFACE_MODE_2500BASEX) ||
436 (fm_eth->enet_if == PHY_INTERFACE_MODE_QSGMII)) &&
437 mac->set_if_mode)
438 mac->set_if_mode(mac, fm_eth->enet_if, SPEED_100);
439
440
441 bmi_rx_port_init(fm_eth->rx_port);
442
443 bmi_tx_port_init(fm_eth->tx_port);
444
445 return 0;
446}
447
448static void fmc_tx_port_graceful_stop_enable(struct fm_eth *fm_eth)
449{
450 struct fm_port_global_pram *pram;
451
452 pram = fm_eth->tx_pram;
453
454 setbits_be32(&pram->mode, PRAM_MODE_GRACEFUL_STOP);
455 sync();
456}
457
458static void fmc_tx_port_graceful_stop_disable(struct fm_eth *fm_eth)
459{
460 struct fm_port_global_pram *pram;
461
462 pram = fm_eth->tx_pram;
463
464 clrbits_be32(&pram->mode, PRAM_MODE_GRACEFUL_STOP);
465 sync();
466}
467
468#ifndef CONFIG_DM_ETH
469static int fm_eth_open(struct eth_device *dev, struct bd_info *bd)
470#else
471static int fm_eth_open(struct udevice *dev)
472#endif
473{
474#ifndef CONFIG_DM_ETH
475 struct fm_eth *fm_eth = dev->priv;
476#else
477 struct eth_pdata *pdata = dev_get_plat(dev);
478 struct fm_eth *fm_eth = dev_get_priv(dev);
479#endif
480 unsigned char *enetaddr;
481 struct fsl_enet_mac *mac;
482#ifdef CONFIG_PHYLIB
483 int ret;
484#endif
485
486 mac = fm_eth->mac;
487
488#ifndef CONFIG_DM_ETH
489 enetaddr = &dev->enetaddr[0];
490#else
491 enetaddr = pdata->enetaddr;
492#endif
493
494
495 if (enetaddr[0] & 0x01) {
496 printf("%s: MacAddress is multicast address\n", __func__);
497 enetaddr[0] = 0;
498 enetaddr[5] = fm_eth->num;
499 }
500 mac->set_mac_addr(mac, enetaddr);
501
502
503 setbits_be32(&fm_eth->rx_port->fmbm_rcfg, FMBM_RCFG_EN);
504
505 mac->enable_mac(mac);
506
507 setbits_be32(&fm_eth->tx_port->fmbm_tcfg, FMBM_TCFG_EN);
508
509 fmc_tx_port_graceful_stop_disable(fm_eth);
510
511#ifdef CONFIG_PHYLIB
512 if (fm_eth->phydev) {
513 ret = phy_startup(fm_eth->phydev);
514 if (ret) {
515#ifndef CONFIG_DM_ETH
516 printf("%s: Could not initialize\n",
517 fm_eth->phydev->dev->name);
518#else
519 printf("%s: Could not initialize\n", dev->name);
520#endif
521 return ret;
522 }
523 } else {
524 return 0;
525 }
526#else
527 fm_eth->phydev->speed = SPEED_1000;
528 fm_eth->phydev->link = 1;
529 fm_eth->phydev->duplex = DUPLEX_FULL;
530#endif
531
532
533 mac->set_if_mode(mac, fm_eth->enet_if, fm_eth->phydev->speed);
534 debug("MAC IF mode %d, speed %d, link %d\n", fm_eth->enet_if,
535 fm_eth->phydev->speed, fm_eth->phydev->link);
536
537 if (!fm_eth->phydev->link)
538 printf("%s: No link.\n", fm_eth->phydev->dev->name);
539
540 return fm_eth->phydev->link ? 0 : -1;
541}
542
543#ifndef CONFIG_DM_ETH
544static void fm_eth_halt(struct eth_device *dev)
545#else
546static void fm_eth_halt(struct udevice *dev)
547#endif
548{
549 struct fm_eth *fm_eth;
550 struct fsl_enet_mac *mac;
551
552#ifndef CONFIG_DM_ETH
553 fm_eth = (struct fm_eth *)dev->priv;
554#else
555 fm_eth = dev_get_priv(dev);
556#endif
557 mac = fm_eth->mac;
558
559
560 fmc_tx_port_graceful_stop_enable(fm_eth);
561
562 bmi_tx_port_disable(fm_eth->tx_port);
563
564 mac->disable_mac(mac);
565
566 bmi_rx_port_disable(fm_eth->rx_port);
567
568#ifdef CONFIG_PHYLIB
569 if (fm_eth->phydev)
570 phy_shutdown(fm_eth->phydev);
571#endif
572}
573
574#ifndef CONFIG_DM_ETH
575static int fm_eth_send(struct eth_device *dev, void *buf, int len)
576#else
577static int fm_eth_send(struct udevice *dev, void *buf, int len)
578#endif
579{
580 struct fm_eth *fm_eth;
581 struct fm_port_global_pram *pram;
582 struct fm_port_bd *txbd, *txbd_base;
583 u16 offset_in;
584 int i;
585
586#ifndef CONFIG_DM_ETH
587 fm_eth = (struct fm_eth *)dev->priv;
588#else
589 fm_eth = dev_get_priv(dev);
590#endif
591 pram = fm_eth->tx_pram;
592 txbd = fm_eth->cur_txbd;
593
594
595 for (i = 0; muram_readw(&txbd->status) & TxBD_READY; i++) {
596 udelay(100);
597 if (i > 0x1000) {
598 printf("%s: Tx buffer not ready, txbd->status = 0x%x\n",
599 dev->name, muram_readw(&txbd->status));
600 return 0;
601 }
602 }
603
604 muram_writew(&txbd->buf_ptr_hi, (u16)upper_32_bits(virt_to_phys(buf)));
605 out_be32(&txbd->buf_ptr_lo, lower_32_bits(virt_to_phys(buf)));
606 muram_writew(&txbd->len, len);
607 sync();
608 muram_writew(&txbd->status, TxBD_READY | TxBD_LAST);
609 sync();
610
611
612 offset_in = muram_readw(&pram->txqd.offset_in);
613 offset_in += sizeof(struct fm_port_bd);
614 if (offset_in >= muram_readw(&pram->txqd.bd_ring_size))
615 offset_in = 0;
616 muram_writew(&pram->txqd.offset_in, offset_in);
617 sync();
618
619
620 for (i = 0; muram_readw(&txbd->status) & TxBD_READY; i++) {
621 udelay(100);
622 if (i > 0x10000) {
623 printf("%s: Tx error, txbd->status = 0x%x\n",
624 dev->name, muram_readw(&txbd->status));
625 return 0;
626 }
627 }
628
629
630 txbd++;
631 txbd_base = (struct fm_port_bd *)fm_eth->tx_bd_ring;
632 if (txbd >= (txbd_base + TX_BD_RING_SIZE))
633 txbd = txbd_base;
634
635 fm_eth->cur_txbd = (void *)txbd;
636
637 return 1;
638}
639
640static struct fm_port_bd *fm_eth_free_one(struct fm_eth *fm_eth,
641 struct fm_port_bd *rxbd)
642{
643 struct fm_port_global_pram *pram;
644 struct fm_port_bd *rxbd_base;
645 u16 offset_out;
646
647 pram = fm_eth->rx_pram;
648
649
650 muram_writew(&rxbd->status, RxBD_EMPTY);
651 muram_writew(&rxbd->len, 0);
652 sync();
653
654
655 rxbd++;
656 rxbd_base = (struct fm_port_bd *)fm_eth->rx_bd_ring;
657 if (rxbd >= (rxbd_base + RX_BD_RING_SIZE))
658 rxbd = rxbd_base;
659
660
661 offset_out = muram_readw(&pram->rxqd.offset_out);
662 offset_out += sizeof(struct fm_port_bd);
663 if (offset_out >= muram_readw(&pram->rxqd.bd_ring_size))
664 offset_out = 0;
665 muram_writew(&pram->rxqd.offset_out, offset_out);
666 sync();
667
668 return rxbd;
669}
670
671#ifndef CONFIG_DM_ETH
672static int fm_eth_recv(struct eth_device *dev)
673#else
674static int fm_eth_recv(struct udevice *dev, int flags, uchar **packetp)
675#endif
676{
677 struct fm_eth *fm_eth;
678 struct fm_port_bd *rxbd;
679 u32 buf_lo, buf_hi;
680 u16 status, len;
681 int ret = -1;
682 u8 *data;
683
684#ifndef CONFIG_DM_ETH
685 fm_eth = (struct fm_eth *)dev->priv;
686#else
687 fm_eth = dev_get_priv(dev);
688#endif
689 rxbd = fm_eth->cur_rxbd;
690 status = muram_readw(&rxbd->status);
691
692 while (!(status & RxBD_EMPTY)) {
693 if (!(status & RxBD_ERROR)) {
694 buf_hi = muram_readw(&rxbd->buf_ptr_hi);
695 buf_lo = in_be32(&rxbd->buf_ptr_lo);
696 data = (u8 *)((ulong)(buf_hi << 16) << 16 | buf_lo);
697 len = muram_readw(&rxbd->len);
698#ifndef CONFIG_DM_ETH
699 net_process_received_packet(data, len);
700#else
701 *packetp = data;
702 return len;
703#endif
704 } else {
705 printf("%s: Rx error\n", dev->name);
706 ret = 0;
707 }
708
709
710 rxbd = fm_eth_free_one(fm_eth, rxbd);
711
712
713 status = muram_readw(&rxbd->status);
714 }
715 fm_eth->cur_rxbd = (void *)rxbd;
716
717 return ret;
718}
719
720#ifdef CONFIG_DM_ETH
721static int fm_eth_free_pkt(struct udevice *dev, uchar *packet, int length)
722{
723 struct fm_eth *fm_eth = (struct fm_eth *)dev_get_priv(dev);
724
725 fm_eth->cur_rxbd = fm_eth_free_one(fm_eth, fm_eth->cur_rxbd);
726
727 return 0;
728}
729#endif
730
731#ifndef CONFIG_DM_ETH
732static int fm_eth_init_mac(struct fm_eth *fm_eth, struct ccsr_fman *reg)
733{
734 struct fsl_enet_mac *mac;
735 int num;
736 void *base, *phyregs = NULL;
737
738 num = fm_eth->num;
739
740#ifdef CONFIG_SYS_FMAN_V3
741#ifndef CONFIG_FSL_FM_10GEC_REGULAR_NOTATION
742 if (fm_eth->type == FM_ETH_10G_E) {
743
744
745
746
747
748 if (fm_eth->num >= 2)
749 num -= 2;
750 else
751 num += 8;
752 }
753#endif
754 base = ®->memac[num].fm_memac;
755 phyregs = ®->memac[num].fm_memac_mdio;
756#else
757
758 if (fm_eth->type == FM_ETH_1G_E) {
759 base = ®->mac_1g[num].fm_dtesc;
760 phyregs = ®->mac_1g[num].fm_mdio.miimcfg;
761 } else {
762 base = ®->mac_10g[num].fm_10gec;
763 phyregs = ®->mac_10g[num].fm_10gec_mdio;
764 }
765#endif
766
767
768 mac = malloc(sizeof(struct fsl_enet_mac));
769 if (!mac)
770 return -ENOMEM;
771 memset(mac, 0, sizeof(struct fsl_enet_mac));
772
773
774 fm_eth->mac = mac;
775
776#ifdef CONFIG_SYS_FMAN_V3
777 init_memac(mac, base, phyregs, MAX_RXBUF_LEN);
778#else
779 if (fm_eth->type == FM_ETH_1G_E)
780 init_dtsec(mac, base, phyregs, MAX_RXBUF_LEN);
781 else
782 init_tgec(mac, base, phyregs, MAX_RXBUF_LEN);
783#endif
784
785 return 0;
786}
787#else
788static int fm_eth_init_mac(struct fm_eth *fm_eth, void *reg)
789{
790#ifndef CONFIG_SYS_FMAN_V3
791 void *mdio;
792#endif
793
794 fm_eth->mac = kzalloc(sizeof(*fm_eth->mac), GFP_KERNEL);
795 if (!fm_eth->mac)
796 return -ENOMEM;
797
798#ifndef CONFIG_SYS_FMAN_V3
799 mdio = fman_mdio(fm_eth->dev->parent, fm_eth->mac_type, fm_eth->num);
800 debug("MDIO %d @ %p\n", fm_eth->num, mdio);
801#endif
802
803 switch (fm_eth->mac_type) {
804#ifdef CONFIG_SYS_FMAN_V3
805 case FM_MEMAC:
806 init_memac(fm_eth->mac, reg, NULL, MAX_RXBUF_LEN);
807 break;
808#else
809 case FM_DTSEC:
810 init_dtsec(fm_eth->mac, reg, mdio, MAX_RXBUF_LEN);
811 break;
812 case FM_TGEC:
813 init_tgec(fm_eth->mac, reg, mdio, MAX_RXBUF_LEN);
814 break;
815#endif
816 }
817
818 return 0;
819}
820#endif
821
822static int init_phy(struct fm_eth *fm_eth)
823{
824#ifdef CONFIG_PHYLIB
825 u32 supported = PHY_GBIT_FEATURES;
826#ifndef CONFIG_DM_ETH
827 struct phy_device *phydev = NULL;
828#endif
829
830 if (fm_eth->type == FM_ETH_10G_E)
831 supported = PHY_10G_FEATURES;
832 if (fm_eth->enet_if == PHY_INTERFACE_MODE_2500BASEX)
833 supported |= SUPPORTED_2500baseX_Full;
834#endif
835
836 if (fm_eth->type == FM_ETH_1G_E)
837 dtsec_init_phy(fm_eth);
838
839#ifdef CONFIG_DM_ETH
840#ifdef CONFIG_PHYLIB
841#ifdef CONFIG_DM_MDIO
842 fm_eth->phydev = dm_eth_phy_connect(fm_eth->dev);
843 if (!fm_eth->phydev)
844 return -ENODEV;
845#endif
846 fm_eth->phydev->advertising &= supported;
847 fm_eth->phydev->supported &= supported;
848
849 phy_config(fm_eth->phydev);
850#endif
851#else
852#ifdef CONFIG_PHYLIB
853 if (fm_eth->bus) {
854 phydev = phy_connect(fm_eth->bus, fm_eth->phyaddr, fm_eth->dev,
855 fm_eth->enet_if);
856 if (!phydev) {
857 printf("Failed to connect\n");
858 return -1;
859 }
860 } else {
861 return 0;
862 }
863
864 if (fm_eth->type == FM_ETH_1G_E) {
865 supported = (SUPPORTED_10baseT_Half |
866 SUPPORTED_10baseT_Full |
867 SUPPORTED_100baseT_Half |
868 SUPPORTED_100baseT_Full |
869 SUPPORTED_1000baseT_Full);
870 } else {
871 supported = SUPPORTED_10000baseT_Full;
872
873 if (tgec_is_fibre(fm_eth))
874 phydev->port = PORT_FIBRE;
875 }
876
877 phydev->supported &= supported;
878 phydev->advertising = phydev->supported;
879
880 fm_eth->phydev = phydev;
881
882 phy_config(phydev);
883#endif
884#endif
885 return 0;
886}
887
888#ifndef CONFIG_DM_ETH
889int fm_eth_initialize(struct ccsr_fman *reg, struct fm_eth_info *info)
890{
891 struct eth_device *dev;
892 struct fm_eth *fm_eth;
893 int i, num = info->num;
894 int ret;
895
896
897 dev = (struct eth_device *)malloc(sizeof(struct eth_device));
898 if (!dev)
899 return -ENOMEM;
900 memset(dev, 0, sizeof(struct eth_device));
901
902
903 fm_eth = (struct fm_eth *)malloc(sizeof(struct fm_eth));
904 if (!fm_eth)
905 return -ENOMEM;
906 memset(fm_eth, 0, sizeof(struct fm_eth));
907
908
909 fm_eth->fm_index = info->index - 1;
910 fm_eth->num = num;
911 fm_eth->type = info->type;
912
913 fm_eth->rx_port = (void *)®->port[info->rx_port_id - 1].fm_bmi;
914 fm_eth->tx_port = (void *)®->port[info->tx_port_id - 1].fm_bmi;
915
916
917 fm_eth->max_rx_len = MAX_RXBUF_LEN;
918
919
920 ret = fm_eth_init_mac(fm_eth, reg);
921 if (ret)
922 return ret;
923
924
925 if (fm_eth->type == FM_ETH_1G_E)
926 sprintf(dev->name, "FM%d@DTSEC%d", info->index, num + 1);
927 else
928 sprintf(dev->name, "FM%d@TGEC%d", info->index, num + 1);
929
930 devlist[num_controllers++] = dev;
931 dev->iobase = 0;
932 dev->priv = (void *)fm_eth;
933 dev->init = fm_eth_open;
934 dev->halt = fm_eth_halt;
935 dev->send = fm_eth_send;
936 dev->recv = fm_eth_recv;
937 fm_eth->dev = dev;
938 fm_eth->bus = info->bus;
939 fm_eth->phyaddr = info->phy_addr;
940 fm_eth->enet_if = info->enet_if;
941
942
943 ret = fm_eth_startup(fm_eth);
944 if (ret)
945 return ret;
946
947 init_phy(fm_eth);
948
949
950 for (i = 0; i < 6; i++)
951 dev->enetaddr[i] = 0;
952 eth_register(dev);
953
954 return 0;
955}
956#else
957#ifdef CONFIG_PHYLIB
958phy_interface_t fman_read_sys_if(struct udevice *dev)
959{
960 const char *if_str;
961
962 if_str = ofnode_read_string(dev_ofnode(dev), "phy-connection-type");
963 debug("MAC system interface mode %s\n", if_str);
964
965 return phy_get_interface_by_name(if_str);
966}
967#endif
968
969static int fm_eth_bind(struct udevice *dev)
970{
971 char mac_name[11];
972 u32 fm, num;
973
974 if (ofnode_read_u32(ofnode_get_parent(dev_ofnode(dev)), "cell-index", &fm)) {
975 printf("FMan node property cell-index missing\n");
976 return -EINVAL;
977 }
978
979 if (dev && dev_read_u32(dev, "cell-index", &num)) {
980 printf("FMan MAC node property cell-index missing\n");
981 return -EINVAL;
982 }
983
984 sprintf(mac_name, "fm%d-mac%d", fm + 1, num + 1);
985 device_set_name(dev, mac_name);
986
987 debug("%s - binding %s\n", __func__, mac_name);
988
989 return 0;
990}
991
992static struct udevice *fm_get_internal_mdio(struct udevice *dev)
993{
994 struct ofnode_phandle_args phandle = {.node = ofnode_null()};
995 struct udevice *mdiodev;
996
997 if (dev_read_phandle_with_args(dev, "pcsphy-handle", NULL,
998 0, 0, &phandle) ||
999 !ofnode_valid(phandle.node)) {
1000 if (dev_read_phandle_with_args(dev, "tbi-handle", NULL,
1001 0, 0, &phandle) ||
1002 !ofnode_valid(phandle.node)) {
1003 printf("Issue reading pcsphy-handle/tbi-handle for MAC %s\n",
1004 dev->name);
1005 return NULL;
1006 }
1007 }
1008
1009 if (uclass_get_device_by_ofnode(UCLASS_MDIO,
1010 ofnode_get_parent(phandle.node),
1011 &mdiodev)) {
1012 printf("can't find MDIO bus for node %s\n",
1013 ofnode_get_name(ofnode_get_parent(phandle.node)));
1014 return NULL;
1015 }
1016 debug("Found internal MDIO bus %p\n", mdiodev);
1017
1018 return mdiodev;
1019}
1020
1021static int fm_eth_probe(struct udevice *dev)
1022{
1023 struct fm_eth *fm_eth = (struct fm_eth *)dev_get_priv(dev);
1024 struct ofnode_phandle_args args;
1025 void *reg;
1026 int ret, index;
1027
1028 debug("%s enter for dev %p fm_eth %p - %s\n", __func__, dev, fm_eth,
1029 (dev) ? dev->name : "-");
1030
1031 if (fm_eth->dev) {
1032 printf("%s already probed, exit\n", (dev) ? dev->name : "-");
1033 return 0;
1034 }
1035
1036 fm_eth->dev = dev;
1037 fm_eth->fm_index = fman_id(dev->parent);
1038 reg = (void *)(uintptr_t)dev_read_addr(dev);
1039 fm_eth->mac_type = dev_get_driver_data(dev);
1040#ifdef CONFIG_PHYLIB
1041 fm_eth->enet_if = fman_read_sys_if(dev);
1042#else
1043 fm_eth->enet_if = PHY_INTERFACE_MODE_SGMII;
1044 printf("%s: warning - unable to determine interface type\n", __func__);
1045#endif
1046 switch (fm_eth->mac_type) {
1047#ifndef CONFIG_SYS_FMAN_V3
1048 case FM_TGEC:
1049 fm_eth->type = FM_ETH_10G_E;
1050 break;
1051 case FM_DTSEC:
1052#else
1053 case FM_MEMAC:
1054
1055#endif
1056 fm_eth->type = FM_ETH_1G_E;
1057 break;
1058 }
1059
1060 if (dev_read_u32(dev, "cell-index", &fm_eth->num)) {
1061 printf("FMan MAC node property cell-index missing\n");
1062 return -EINVAL;
1063 }
1064
1065 if (dev_read_phandle_with_args(dev, "fsl,fman-ports", NULL,
1066 0, 0, &args))
1067 goto ports_ref_failure;
1068 index = ofnode_read_u32_default(args.node, "cell-index", 0);
1069 if (index <= 0)
1070 goto ports_ref_failure;
1071 fm_eth->rx_port = fman_port(dev->parent, index);
1072
1073 if (ofnode_read_bool(args.node, "fsl,fman-10g-port"))
1074 fm_eth->type = FM_ETH_10G_E;
1075
1076 if (dev_read_phandle_with_args(dev, "fsl,fman-ports", NULL,
1077 0, 1, &args))
1078 goto ports_ref_failure;
1079 index = ofnode_read_u32_default(args.node, "cell-index", 0);
1080 if (index <= 0)
1081 goto ports_ref_failure;
1082 fm_eth->tx_port = fman_port(dev->parent, index);
1083
1084
1085 fm_eth->max_rx_len = MAX_RXBUF_LEN;
1086
1087 switch (fm_eth->enet_if) {
1088 case PHY_INTERFACE_MODE_QSGMII:
1089
1090 if (fm_eth->num != 0)
1091 break;
1092 case PHY_INTERFACE_MODE_SGMII:
1093 case PHY_INTERFACE_MODE_2500BASEX:
1094 fm_eth->pcs_mdio = fm_get_internal_mdio(dev);
1095 break;
1096 default:
1097 break;
1098 }
1099
1100
1101 ret = fm_eth_init_mac(fm_eth, reg);
1102 if (ret)
1103 return ret;
1104
1105
1106 ret = fm_eth_startup(fm_eth);
1107
1108 if (!ret)
1109 ret = init_phy(fm_eth);
1110
1111 return ret;
1112
1113ports_ref_failure:
1114 printf("Issue reading fsl,fman-ports for MAC %s\n", dev->name);
1115 return -ENOENT;
1116}
1117
1118static int fm_eth_remove(struct udevice *dev)
1119{
1120 return 0;
1121}
1122
1123static const struct eth_ops fm_eth_ops = {
1124 .start = fm_eth_open,
1125 .send = fm_eth_send,
1126 .recv = fm_eth_recv,
1127 .free_pkt = fm_eth_free_pkt,
1128 .stop = fm_eth_halt,
1129};
1130
1131static const struct udevice_id fm_eth_ids[] = {
1132#ifdef CONFIG_SYS_FMAN_V3
1133 { .compatible = "fsl,fman-memac", .data = FM_MEMAC },
1134#else
1135 { .compatible = "fsl,fman-dtsec", .data = FM_DTSEC },
1136 { .compatible = "fsl,fman-xgec", .data = FM_TGEC },
1137#endif
1138 {}
1139};
1140
1141U_BOOT_DRIVER(eth_fman) = {
1142 .name = "eth_fman",
1143 .id = UCLASS_ETH,
1144 .of_match = fm_eth_ids,
1145 .bind = fm_eth_bind,
1146 .probe = fm_eth_probe,
1147 .remove = fm_eth_remove,
1148 .ops = &fm_eth_ops,
1149 .priv_auto = sizeof(struct fm_eth),
1150 .plat_auto = sizeof(struct eth_pdata),
1151 .flags = DM_FLAG_ALLOC_PRIV_DMA,
1152};
1153#endif
1154
