]>
git.ipfire.org Git - people/ms/u-boot.git/blob - drivers/net/mpc512x_fec.c
2 * (C) Copyright 2003-2010
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5 * Derived from the MPC8xx FEC driver.
6 * Adapted for MPC512x by Grzegorz Bernacki <gjb@semihalf.com>
15 #include "mpc512x_fec.h"
17 DECLARE_GLOBAL_DATA_PTR
;
21 #if !(defined(CONFIG_MII) || defined(CONFIG_CMD_MII))
22 #error "CONFIG_MII has to be defined!"
25 int fec512x_miiphy_read(const char *devname
, u8 phyAddr
, u8 regAddr
, u16
* retVal
);
26 int fec512x_miiphy_write(const char *devname
, u8 phyAddr
, u8 regAddr
, u16 data
);
27 int mpc512x_fec_init_phy(struct eth_device
*dev
, bd_t
* bis
);
29 static uchar rx_buff
[FEC_BUFFER_SIZE
];
30 static int rx_buff_idx
= 0;
32 /********************************************************************/
34 static void mpc512x_fec_phydump (char *devname
)
37 u8 phyAddr
= CONFIG_PHY_ADDR
;
39 /* regs to print: 0...8, 21,27,31 */
40 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
41 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1,
44 for (i
= 0; i
< 32; i
++) {
46 miiphy_read (devname
, phyAddr
, i
, &phyStatus
);
47 printf ("Mii reg %d: 0x%04x\n", i
, phyStatus
);
53 /********************************************************************/
54 static int mpc512x_fec_bd_init (mpc512x_fec_priv
*fec
)
61 for (ix
= 0; ix
< FEC_RBD_NUM
; ix
++) {
62 fec
->bdBase
->rbd
[ix
].dataPointer
=
63 (u32
)&fec
->bdBase
->recv_frames
[ix
];
64 fec
->bdBase
->rbd
[ix
].status
= FEC_RBD_EMPTY
;
65 fec
->bdBase
->rbd
[ix
].dataLength
= 0;
69 * have the last RBD to close the ring
71 fec
->bdBase
->rbd
[ix
- 1].status
|= FEC_RBD_WRAP
;
77 for (ix
= 0; ix
< FEC_TBD_NUM
; ix
++) {
78 fec
->bdBase
->tbd
[ix
].status
= 0;
82 * Have the last TBD to close the ring
84 fec
->bdBase
->tbd
[ix
- 1].status
|= FEC_TBD_WRAP
;
87 * Initialize some indices
90 fec
->usedTbdIndex
= 0;
91 fec
->cleanTbdNum
= FEC_TBD_NUM
;
96 /********************************************************************/
97 static void mpc512x_fec_rbd_clean (mpc512x_fec_priv
*fec
, volatile FEC_RBD
* pRbd
)
100 * Reset buffer descriptor as empty
102 if ((fec
->rbdIndex
) == (FEC_RBD_NUM
- 1))
103 pRbd
->status
= (FEC_RBD_WRAP
| FEC_RBD_EMPTY
);
105 pRbd
->status
= FEC_RBD_EMPTY
;
107 pRbd
->dataLength
= 0;
112 fec
->rbdIndex
= (fec
->rbdIndex
+ 1) % FEC_RBD_NUM
;
115 * Now, we have an empty RxBD, notify FEC
116 * Set Descriptor polling active
118 out_be32(&fec
->eth
->r_des_active
, 0x01000000);
121 /********************************************************************/
122 static void mpc512x_fec_tbd_scrub (mpc512x_fec_priv
*fec
)
124 volatile FEC_TBD
*pUsedTbd
;
127 printf ("tbd_scrub: fec->cleanTbdNum = %d, fec->usedTbdIndex = %d\n",
128 fec
->cleanTbdNum
, fec
->usedTbdIndex
);
132 * process all the consumed TBDs
134 while (fec
->cleanTbdNum
< FEC_TBD_NUM
) {
135 pUsedTbd
= &fec
->bdBase
->tbd
[fec
->usedTbdIndex
];
136 if (pUsedTbd
->status
& FEC_TBD_READY
) {
138 printf ("Cannot clean TBD %d, in use\n", fec
->usedTbdIndex
);
144 * clean this buffer descriptor
146 if (fec
->usedTbdIndex
== (FEC_TBD_NUM
- 1))
147 pUsedTbd
->status
= FEC_TBD_WRAP
;
149 pUsedTbd
->status
= 0;
152 * update some indeces for a correct handling of the TBD ring
155 fec
->usedTbdIndex
= (fec
->usedTbdIndex
+ 1) % FEC_TBD_NUM
;
159 /********************************************************************/
160 static void mpc512x_fec_set_hwaddr (mpc512x_fec_priv
*fec
, unsigned char *mac
)
162 u8 currByte
; /* byte for which to compute the CRC */
163 int byte
; /* loop - counter */
164 int bit
; /* loop - counter */
165 u32 crc
= 0xffffffff; /* initial value */
168 * The algorithm used is the following:
169 * we loop on each of the six bytes of the provided address,
170 * and we compute the CRC by left-shifting the previous
171 * value by one position, so that each bit in the current
172 * byte of the address may contribute the calculation. If
173 * the latter and the MSB in the CRC are different, then
174 * the CRC value so computed is also ex-ored with the
175 * "polynomium generator". The current byte of the address
176 * is also shifted right by one bit at each iteration.
177 * This is because the CRC generatore in hardware is implemented
178 * as a shift-register with as many ex-ores as the radixes
179 * in the polynomium. This suggests that we represent the
180 * polynomiumm itself as a 32-bit constant.
182 for (byte
= 0; byte
< 6; byte
++) {
183 currByte
= mac
[byte
];
184 for (bit
= 0; bit
< 8; bit
++) {
185 if ((currByte
& 0x01) ^ (crc
& 0x01)) {
187 crc
= crc
^ 0xedb88320;
198 * Set individual hash table register
201 out_be32(&fec
->eth
->iaddr1
, (1 << (crc
- 32)));
202 out_be32(&fec
->eth
->iaddr2
, 0);
204 out_be32(&fec
->eth
->iaddr1
, 0);
205 out_be32(&fec
->eth
->iaddr2
, (1 << crc
));
209 * Set physical address
211 out_be32(&fec
->eth
->paddr1
, (mac
[0] << 24) + (mac
[1] << 16) +
212 (mac
[2] << 8) + mac
[3]);
213 out_be32(&fec
->eth
->paddr2
, (mac
[4] << 24) + (mac
[5] << 16) +
217 /********************************************************************/
218 static int mpc512x_fec_init (struct eth_device
*dev
, bd_t
* bis
)
220 mpc512x_fec_priv
*fec
= (mpc512x_fec_priv
*)dev
->priv
;
223 printf ("mpc512x_fec_init... Begin\n");
226 mpc512x_fec_set_hwaddr (fec
, dev
->enetaddr
);
227 out_be32(&fec
->eth
->gaddr1
, 0x00000000);
228 out_be32(&fec
->eth
->gaddr2
, 0x00000000);
230 mpc512x_fec_init_phy (dev
, bis
);
232 /* Set interrupt mask register */
233 out_be32(&fec
->eth
->imask
, 0x00000000);
235 /* Clear FEC-Lite interrupt event register(IEVENT) */
236 out_be32(&fec
->eth
->ievent
, 0xffffffff);
238 /* Set transmit fifo watermark register(X_WMRK), default = 64 */
239 out_be32(&fec
->eth
->x_wmrk
, 0x0);
241 /* Set Opcode/Pause Duration Register */
242 out_be32(&fec
->eth
->op_pause
, 0x00010020);
244 /* Frame length=1522; MII mode */
245 out_be32(&fec
->eth
->r_cntrl
, (FEC_MAX_FRAME_LEN
<< 16) | 0x24);
247 /* Half-duplex, heartbeat disabled */
248 out_be32(&fec
->eth
->x_cntrl
, 0x00000000);
250 /* Enable MIB counters */
251 out_be32(&fec
->eth
->mib_control
, 0x0);
253 /* Setup recv fifo start and buff size */
254 out_be32(&fec
->eth
->r_fstart
, 0x500);
255 out_be32(&fec
->eth
->r_buff_size
, FEC_BUFFER_SIZE
);
257 /* Setup BD base addresses */
258 out_be32(&fec
->eth
->r_des_start
, (u32
)fec
->bdBase
->rbd
);
259 out_be32(&fec
->eth
->x_des_start
, (u32
)fec
->bdBase
->tbd
);
262 out_be32(&fec
->eth
->dma_control
, 0xc0000000);
265 setbits_be32(&fec
->eth
->ecntrl
, 0x00000006);
267 /* Initilize addresses and status words of BDs */
268 mpc512x_fec_bd_init (fec
);
270 /* Descriptor polling active */
271 out_be32(&fec
->eth
->r_des_active
, 0x01000000);
274 printf("mpc512x_fec_init... Done \n");
279 /********************************************************************/
280 int mpc512x_fec_init_phy (struct eth_device
*dev
, bd_t
* bis
)
282 mpc512x_fec_priv
*fec
= (mpc512x_fec_priv
*)dev
->priv
;
283 const u8 phyAddr
= CONFIG_PHY_ADDR
; /* Only one PHY */
288 printf ("mpc512x_fec_init_phy... Begin\n");
292 * Clear FEC-Lite interrupt event register(IEVENT)
294 out_be32(&fec
->eth
->ievent
, 0xffffffff);
297 * Set interrupt mask register
299 out_be32(&fec
->eth
->imask
, 0x00000000);
301 if (fec
->xcv_type
!= SEVENWIRE
) {
303 * Set MII_SPEED = (1/(mii_speed * 2)) * System Clock
304 * and do not drop the Preamble.
306 out_be32(&fec
->eth
->mii_speed
,
307 (((gd
->arch
.ips_clk
/ 1000000) / 5) + 1) << 1);
310 * Reset PHY, then delay 300ns
312 miiphy_write (dev
->name
, phyAddr
, 0x0, 0x8000);
315 if (fec
->xcv_type
== MII10
) {
317 * Force 10Base-T, FDX operation
320 printf ("Forcing 10 Mbps ethernet link... ");
322 miiphy_read (dev
->name
, phyAddr
, 0x1, &phyStatus
);
324 miiphy_write (dev
->name
, phyAddr
, 0x0, 0x0180);
327 do { /* wait for link status to go down */
329 if ((timeout
--) == 0) {
331 printf ("hmmm, should not have waited...");
335 miiphy_read (dev
->name
, phyAddr
, 0x1, &phyStatus
);
339 } while ((phyStatus
& 0x0004)); /* !link up */
342 do { /* wait for link status to come back up */
344 if ((timeout
--) == 0) {
345 printf ("failed. Link is down.\n");
348 miiphy_read (dev
->name
, phyAddr
, 0x1, &phyStatus
);
352 } while (!(phyStatus
& 0x0004)); /* !link up */
357 } else { /* MII100 */
359 * Set the auto-negotiation advertisement register bits
361 miiphy_write (dev
->name
, phyAddr
, 0x4, 0x01e1);
364 * Set MDIO bit 0.12 = 1(&& bit 0.9=1?) to enable auto-negotiation
366 miiphy_write (dev
->name
, phyAddr
, 0x0, 0x1200);
369 * Wait for AN completion
375 if ((timeout
--) == 0) {
377 printf ("PHY auto neg 0 failed...\n");
382 if (miiphy_read (dev
->name
, phyAddr
, 0x1, &phyStatus
) != 0) {
384 printf ("PHY auto neg 1 failed 0x%04x...\n", phyStatus
);
388 } while (!(phyStatus
& 0x0004));
391 printf ("PHY auto neg complete! \n");
397 if (fec
->xcv_type
!= SEVENWIRE
)
398 mpc512x_fec_phydump (dev
->name
);
402 printf ("mpc512x_fec_init_phy... Done \n");
407 /********************************************************************/
408 static void mpc512x_fec_halt (struct eth_device
*dev
)
410 mpc512x_fec_priv
*fec
= (mpc512x_fec_priv
*)dev
->priv
;
411 int counter
= 0xffff;
414 if (fec
->xcv_type
!= SEVENWIRE
)
415 mpc512x_fec_phydump (dev
->name
);
419 * mask FEC chip interrupts
421 out_be32(&fec
->eth
->imask
, 0);
424 * issue graceful stop command to the FEC transmitter if necessary
426 setbits_be32(&fec
->eth
->x_cntrl
, 0x00000001);
429 * wait for graceful stop to register
431 while ((counter
--) && (!(in_be32(&fec
->eth
->ievent
) & 0x10000000)))
435 * Disable the Ethernet Controller
437 clrbits_be32(&fec
->eth
->ecntrl
, 0x00000002);
440 * Issue a reset command to the FEC chip
442 setbits_be32(&fec
->eth
->ecntrl
, 0x1);
445 * wait at least 16 clock cycles
449 printf ("Ethernet task stopped\n");
453 /********************************************************************/
455 static int mpc512x_fec_send(struct eth_device
*dev
, void *eth_data
,
459 * This routine transmits one frame. This routine only accepts
460 * 6-byte Ethernet addresses.
462 mpc512x_fec_priv
*fec
= (mpc512x_fec_priv
*)dev
->priv
;
463 volatile FEC_TBD
*pTbd
;
466 printf("tbd status: 0x%04x\n", fec
->tbdBase
[fec
->tbdIndex
].status
);
470 * Clear Tx BD ring at first
472 mpc512x_fec_tbd_scrub (fec
);
475 * Check for valid length of data.
477 if ((data_length
> 1500) || (data_length
<= 0)) {
482 * Check the number of vacant TxBDs.
484 if (fec
->cleanTbdNum
< 1) {
486 printf ("No available TxBDs ...\n");
492 * Get the first TxBD to send the mac header
494 pTbd
= &fec
->bdBase
->tbd
[fec
->tbdIndex
];
495 pTbd
->dataLength
= data_length
;
496 pTbd
->dataPointer
= (u32
)eth_data
;
497 pTbd
->status
|= FEC_TBD_LAST
| FEC_TBD_TC
| FEC_TBD_READY
;
498 fec
->tbdIndex
= (fec
->tbdIndex
+ 1) % FEC_TBD_NUM
;
500 /* Activate transmit Buffer Descriptor polling */
501 out_be32(&fec
->eth
->x_des_active
, 0x01000000);
507 fec
->cleanTbdNum
-= 1;
510 * wait until frame is sent .
512 while (pTbd
->status
& FEC_TBD_READY
) {
515 printf ("TDB status = %04x\n", pTbd
->status
);
523 /********************************************************************/
524 static int mpc512x_fec_recv (struct eth_device
*dev
)
527 * This command pulls one frame from the card
529 mpc512x_fec_priv
*fec
= (mpc512x_fec_priv
*)dev
->priv
;
530 volatile FEC_RBD
*pRbd
= &fec
->bdBase
->rbd
[fec
->rbdIndex
];
531 unsigned long ievent
;
532 int frame_length
= 0;
535 printf ("mpc512x_fec_recv %d Start...\n", fec
->rbdIndex
);
542 * Check if any critical events have happened
544 ievent
= in_be32(&fec
->eth
->ievent
);
545 out_be32(&fec
->eth
->ievent
, ievent
);
546 if (ievent
& 0x20060000) {
547 /* BABT, Rx/Tx FIFO errors */
548 mpc512x_fec_halt (dev
);
549 mpc512x_fec_init (dev
, NULL
);
552 if (ievent
& 0x80000000) {
553 /* Heartbeat error */
554 setbits_be32(&fec
->eth
->x_cntrl
, 0x00000001);
556 if (ievent
& 0x10000000) {
557 /* Graceful stop complete */
558 if (in_be32(&fec
->eth
->x_cntrl
) & 0x00000001) {
559 mpc512x_fec_halt (dev
);
560 clrbits_be32(&fec
->eth
->x_cntrl
, 0x00000001);;
561 mpc512x_fec_init (dev
, NULL
);
565 if (!(pRbd
->status
& FEC_RBD_EMPTY
)) {
566 if (!(pRbd
->status
& FEC_RBD_ERR
) &&
567 ((pRbd
->dataLength
- 4) > 14)) {
572 if (pRbd
->status
& FEC_RBD_LAST
)
573 frame_length
= pRbd
->dataLength
- 4;
575 frame_length
= pRbd
->dataLength
;
579 printf ("recv data length 0x%08x data hdr: ",
581 for (i
= 0; i
< 14; i
++)
582 printf ("%x ", *((u8
*)pRbd
->dataPointer
+ i
));
587 * Fill the buffer and pass it to upper layers
589 memcpy (&rx_buff
[rx_buff_idx
], (void*)pRbd
->dataPointer
,
590 frame_length
- rx_buff_idx
);
591 rx_buff_idx
= frame_length
;
593 if (pRbd
->status
& FEC_RBD_LAST
) {
594 net_process_received_packet((uchar
*)rx_buff
,
601 * Reset buffer descriptor as empty
603 mpc512x_fec_rbd_clean (fec
, pRbd
);
606 /* Try to fill Buffer Descriptors */
607 out_be32(&fec
->eth
->r_des_active
, 0x01000000);
612 /********************************************************************/
613 int mpc512x_fec_initialize (bd_t
* bis
)
615 volatile immap_t
*im
= (immap_t
*) CONFIG_SYS_IMMR
;
616 mpc512x_fec_priv
*fec
;
617 struct eth_device
*dev
;
620 fec
= (mpc512x_fec_priv
*) malloc (sizeof(*fec
));
621 dev
= (struct eth_device
*) malloc (sizeof(*dev
));
622 memset (dev
, 0, sizeof *dev
);
626 # ifndef CONFIG_FEC_10MBIT
627 fec
->xcv_type
= MII100
;
629 fec
->xcv_type
= MII10
;
631 dev
->priv
= (void *)fec
;
632 dev
->iobase
= (int)&im
->fec
;
633 dev
->init
= mpc512x_fec_init
;
634 dev
->halt
= mpc512x_fec_halt
;
635 dev
->send
= mpc512x_fec_send
;
636 dev
->recv
= mpc512x_fec_recv
;
638 sprintf (dev
->name
, "FEC");
641 #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
642 miiphy_register (dev
->name
,
643 fec512x_miiphy_read
, fec512x_miiphy_write
);
646 /* Clean up space FEC's MIB and FIFO RAM ...*/
647 memset ((void *)&im
->fec
.mib
, 0x00, sizeof(im
->fec
.mib
));
648 memset ((void *)&im
->fec
.fifo
, 0x00, sizeof(im
->fec
.fifo
));
651 * Malloc space for BDs (must be quad word-aligned)
652 * this pointer is lost, so cannot be freed
654 bd
= malloc (sizeof(mpc512x_buff_descs
) + 0x1f);
655 fec
->bdBase
= (mpc512x_buff_descs
*)((u32
)bd
& 0xfffffff0);
656 memset ((void *) bd
, 0x00, sizeof(mpc512x_buff_descs
) + 0x1f);
659 * Set interrupt mask register
661 out_be32(&fec
->eth
->imask
, 0x00000000);
664 * Clear FEC-Lite interrupt event register(IEVENT)
666 out_be32(&fec
->eth
->ievent
, 0xffffffff);
671 /* MII-interface related functions */
672 /********************************************************************/
673 int fec512x_miiphy_read(const char *devname
, u8 phyAddr
, u8 regAddr
, u16
*retVal
)
675 volatile immap_t
*im
= (immap_t
*) CONFIG_SYS_IMMR
;
676 volatile fec512x_t
*eth
= &im
->fec
;
677 u32 reg
; /* convenient holder for the PHY register */
678 u32 phy
; /* convenient holder for the PHY */
679 int timeout
= 0xffff;
682 * reading from any PHY's register is done by properly
683 * programming the FEC's MII data register.
685 reg
= regAddr
<< FEC_MII_DATA_RA_SHIFT
;
686 phy
= phyAddr
<< FEC_MII_DATA_PA_SHIFT
;
688 out_be32(ð
->mii_data
, FEC_MII_DATA_ST
|
694 * wait for the related interrupt
696 while ((timeout
--) && (!(in_be32(ð
->ievent
) & 0x00800000)))
701 printf ("Read MDIO failed...\n");
707 * clear mii interrupt bit
709 out_be32(ð
->ievent
, 0x00800000);
712 * it's now safe to read the PHY's register
714 *retVal
= (u16
) in_be32(ð
->mii_data
);
719 /********************************************************************/
720 int fec512x_miiphy_write(const char *devname
, u8 phyAddr
, u8 regAddr
, u16 data
)
722 volatile immap_t
*im
= (immap_t
*) CONFIG_SYS_IMMR
;
723 volatile fec512x_t
*eth
= &im
->fec
;
724 u32 reg
; /* convenient holder for the PHY register */
725 u32 phy
; /* convenient holder for the PHY */
726 int timeout
= 0xffff;
728 reg
= regAddr
<< FEC_MII_DATA_RA_SHIFT
;
729 phy
= phyAddr
<< FEC_MII_DATA_PA_SHIFT
;
731 out_be32(ð
->mii_data
, FEC_MII_DATA_ST
|
737 * wait for the MII interrupt
739 while ((timeout
--) && (!(in_be32(ð
->ievent
) & 0x00800000)))
744 printf ("Write MDIO failed...\n");
750 * clear MII interrupt bit
752 out_be32(ð
->ievent
, 0x00800000);