iwlwifi: parametrize configuration of the PLL for exclusion on 6000
[linux-2.6] / drivers / net / fec.c
1 /*
2  * Fast Ethernet Controller (FEC) driver for Motorola MPC8xx.
3  * Copyright (c) 1997 Dan Malek (dmalek@jlc.net)
4  *
5  * Right now, I am very wasteful with the buffers.  I allocate memory
6  * pages and then divide them into 2K frame buffers.  This way I know I
7  * have buffers large enough to hold one frame within one buffer descriptor.
8  * Once I get this working, I will use 64 or 128 byte CPM buffers, which
9  * will be much more memory efficient and will easily handle lots of
10  * small packets.
11  *
12  * Much better multiple PHY support by Magnus Damm.
13  * Copyright (c) 2000 Ericsson Radio Systems AB.
14  *
15  * Support for FEC controller of ColdFire processors.
16  * Copyright (c) 2001-2005 Greg Ungerer (gerg@snapgear.com)
17  *
18  * Bug fixes and cleanup by Philippe De Muyter (phdm@macqel.be)
19  * Copyright (c) 2004-2006 Macq Electronique SA.
20  */
21
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/string.h>
25 #include <linux/ptrace.h>
26 #include <linux/errno.h>
27 #include <linux/ioport.h>
28 #include <linux/slab.h>
29 #include <linux/interrupt.h>
30 #include <linux/pci.h>
31 #include <linux/init.h>
32 #include <linux/delay.h>
33 #include <linux/netdevice.h>
34 #include <linux/etherdevice.h>
35 #include <linux/skbuff.h>
36 #include <linux/spinlock.h>
37 #include <linux/workqueue.h>
38 #include <linux/bitops.h>
39 #include <linux/io.h>
40 #include <linux/irq.h>
41 #include <linux/clk.h>
42 #include <linux/platform_device.h>
43
44 #include <asm/cacheflush.h>
45
46 #ifndef CONFIG_ARCH_MXC
47 #include <asm/coldfire.h>
48 #include <asm/mcfsim.h>
49 #endif
50
51 #include "fec.h"
52
53 #ifdef CONFIG_ARCH_MXC
54 #include <mach/hardware.h>
55 #define FEC_ALIGNMENT   0xf
56 #else
57 #define FEC_ALIGNMENT   0x3
58 #endif
59
60 #if defined CONFIG_M5272 || defined CONFIG_M527x || defined CONFIG_M523x \
61         || defined CONFIG_M528x || defined CONFIG_M532x || defined CONFIG_M520x
62 #define FEC_LEGACY
63 /*
64  * Define the fixed address of the FEC hardware.
65  */
66 #if defined(CONFIG_M5272)
67 #define HAVE_mii_link_interrupt
68 #endif
69
70 #if defined(CONFIG_FEC2)
71 #define FEC_MAX_PORTS   2
72 #else
73 #define FEC_MAX_PORTS   1
74 #endif
75
76 static unsigned int fec_hw[] = {
77 #if defined(CONFIG_M5272)
78         (MCF_MBAR + 0x840),
79 #elif defined(CONFIG_M527x)
80         (MCF_MBAR + 0x1000),
81         (MCF_MBAR + 0x1800),
82 #elif defined(CONFIG_M523x) || defined(CONFIG_M528x)
83         (MCF_MBAR + 0x1000),
84 #elif defined(CONFIG_M520x)
85         (MCF_MBAR+0x30000),
86 #elif defined(CONFIG_M532x)
87         (MCF_MBAR+0xfc030000),
88 #endif
89 };
90
91 static unsigned char    fec_mac_default[] = {
92         0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
93 };
94
95 /*
96  * Some hardware gets it MAC address out of local flash memory.
97  * if this is non-zero then assume it is the address to get MAC from.
98  */
99 #if defined(CONFIG_NETtel)
100 #define FEC_FLASHMAC    0xf0006006
101 #elif defined(CONFIG_GILBARCONAP) || defined(CONFIG_SCALES)
102 #define FEC_FLASHMAC    0xf0006000
103 #elif defined(CONFIG_CANCam)
104 #define FEC_FLASHMAC    0xf0020000
105 #elif defined (CONFIG_M5272C3)
106 #define FEC_FLASHMAC    (0xffe04000 + 4)
107 #elif defined(CONFIG_MOD5272)
108 #define FEC_FLASHMAC    0xffc0406b
109 #else
110 #define FEC_FLASHMAC    0
111 #endif
112
113 #endif /* FEC_LEGACY */
114
115 /* Forward declarations of some structures to support different PHYs
116 */
117
118 typedef struct {
119         uint mii_data;
120         void (*funct)(uint mii_reg, struct net_device *dev);
121 } phy_cmd_t;
122
123 typedef struct {
124         uint id;
125         char *name;
126
127         const phy_cmd_t *config;
128         const phy_cmd_t *startup;
129         const phy_cmd_t *ack_int;
130         const phy_cmd_t *shutdown;
131 } phy_info_t;
132
133 /* The number of Tx and Rx buffers.  These are allocated from the page
134  * pool.  The code may assume these are power of two, so it it best
135  * to keep them that size.
136  * We don't need to allocate pages for the transmitter.  We just use
137  * the skbuffer directly.
138  */
139 #define FEC_ENET_RX_PAGES       8
140 #define FEC_ENET_RX_FRSIZE      2048
141 #define FEC_ENET_RX_FRPPG       (PAGE_SIZE / FEC_ENET_RX_FRSIZE)
142 #define RX_RING_SIZE            (FEC_ENET_RX_FRPPG * FEC_ENET_RX_PAGES)
143 #define FEC_ENET_TX_FRSIZE      2048
144 #define FEC_ENET_TX_FRPPG       (PAGE_SIZE / FEC_ENET_TX_FRSIZE)
145 #define TX_RING_SIZE            16      /* Must be power of two */
146 #define TX_RING_MOD_MASK        15      /*   for this to work */
147
148 #if (((RX_RING_SIZE + TX_RING_SIZE) * 8) > PAGE_SIZE)
149 #error "FEC: descriptor ring size constants too large"
150 #endif
151
152 /* Interrupt events/masks.
153 */
154 #define FEC_ENET_HBERR  ((uint)0x80000000)      /* Heartbeat error */
155 #define FEC_ENET_BABR   ((uint)0x40000000)      /* Babbling receiver */
156 #define FEC_ENET_BABT   ((uint)0x20000000)      /* Babbling transmitter */
157 #define FEC_ENET_GRA    ((uint)0x10000000)      /* Graceful stop complete */
158 #define FEC_ENET_TXF    ((uint)0x08000000)      /* Full frame transmitted */
159 #define FEC_ENET_TXB    ((uint)0x04000000)      /* A buffer was transmitted */
160 #define FEC_ENET_RXF    ((uint)0x02000000)      /* Full frame received */
161 #define FEC_ENET_RXB    ((uint)0x01000000)      /* A buffer was received */
162 #define FEC_ENET_MII    ((uint)0x00800000)      /* MII interrupt */
163 #define FEC_ENET_EBERR  ((uint)0x00400000)      /* SDMA bus error */
164
165 /* The FEC stores dest/src/type, data, and checksum for receive packets.
166  */
167 #define PKT_MAXBUF_SIZE         1518
168 #define PKT_MINBUF_SIZE         64
169 #define PKT_MAXBLR_SIZE         1520
170
171
172 /*
173  * The 5270/5271/5280/5282/532x RX control register also contains maximum frame
174  * size bits. Other FEC hardware does not, so we need to take that into
175  * account when setting it.
176  */
177 #if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
178     defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARCH_MXC)
179 #define OPT_FRAME_SIZE  (PKT_MAXBUF_SIZE << 16)
180 #else
181 #define OPT_FRAME_SIZE  0
182 #endif
183
184 /* The FEC buffer descriptors track the ring buffers.  The rx_bd_base and
185  * tx_bd_base always point to the base of the buffer descriptors.  The
186  * cur_rx and cur_tx point to the currently available buffer.
187  * The dirty_tx tracks the current buffer that is being sent by the
188  * controller.  The cur_tx and dirty_tx are equal under both completely
189  * empty and completely full conditions.  The empty/ready indicator in
190  * the buffer descriptor determines the actual condition.
191  */
192 struct fec_enet_private {
193         /* Hardware registers of the FEC device */
194         volatile fec_t  *hwp;
195
196         struct net_device *netdev;
197
198         struct clk *clk;
199
200         /* The saved address of a sent-in-place packet/buffer, for skfree(). */
201         unsigned char *tx_bounce[TX_RING_SIZE];
202         struct  sk_buff* tx_skbuff[TX_RING_SIZE];
203         ushort  skb_cur;
204         ushort  skb_dirty;
205
206         /* CPM dual port RAM relative addresses.
207         */
208         dma_addr_t      bd_dma;
209         cbd_t   *rx_bd_base;            /* Address of Rx and Tx buffers. */
210         cbd_t   *tx_bd_base;
211         cbd_t   *cur_rx, *cur_tx;               /* The next free ring entry */
212         cbd_t   *dirty_tx;      /* The ring entries to be free()ed. */
213         uint    tx_full;
214         /* hold while accessing the HW like ringbuffer for tx/rx but not MAC */
215         spinlock_t hw_lock;
216         /* hold while accessing the mii_list_t() elements */
217         spinlock_t mii_lock;
218
219         uint    phy_id;
220         uint    phy_id_done;
221         uint    phy_status;
222         uint    phy_speed;
223         phy_info_t const        *phy;
224         struct work_struct phy_task;
225
226         uint    sequence_done;
227         uint    mii_phy_task_queued;
228
229         uint    phy_addr;
230
231         int     index;
232         int     opened;
233         int     link;
234         int     old_link;
235         int     full_duplex;
236 };
237
238 static int fec_enet_open(struct net_device *dev);
239 static int fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev);
240 static void fec_enet_mii(struct net_device *dev);
241 static irqreturn_t fec_enet_interrupt(int irq, void * dev_id);
242 static void fec_enet_tx(struct net_device *dev);
243 static void fec_enet_rx(struct net_device *dev);
244 static int fec_enet_close(struct net_device *dev);
245 static void set_multicast_list(struct net_device *dev);
246 static void fec_restart(struct net_device *dev, int duplex);
247 static void fec_stop(struct net_device *dev);
248 static void fec_set_mac_address(struct net_device *dev);
249
250
251 /* MII processing.  We keep this as simple as possible.  Requests are
252  * placed on the list (if there is room).  When the request is finished
253  * by the MII, an optional function may be called.
254  */
255 typedef struct mii_list {
256         uint    mii_regval;
257         void    (*mii_func)(uint val, struct net_device *dev);
258         struct  mii_list *mii_next;
259 } mii_list_t;
260
261 #define         NMII    20
262 static mii_list_t       mii_cmds[NMII];
263 static mii_list_t       *mii_free;
264 static mii_list_t       *mii_head;
265 static mii_list_t       *mii_tail;
266
267 static int      mii_queue(struct net_device *dev, int request,
268                                 void (*func)(uint, struct net_device *));
269
270 /* Make MII read/write commands for the FEC.
271 */
272 #define mk_mii_read(REG)        (0x60020000 | ((REG & 0x1f) << 18))
273 #define mk_mii_write(REG, VAL)  (0x50020000 | ((REG & 0x1f) << 18) | \
274                                                 (VAL & 0xffff))
275 #define mk_mii_end      0
276
277 /* Transmitter timeout.
278 */
279 #define TX_TIMEOUT (2*HZ)
280
281 /* Register definitions for the PHY.
282 */
283
284 #define MII_REG_CR          0  /* Control Register                         */
285 #define MII_REG_SR          1  /* Status Register                          */
286 #define MII_REG_PHYIR1      2  /* PHY Identification Register 1            */
287 #define MII_REG_PHYIR2      3  /* PHY Identification Register 2            */
288 #define MII_REG_ANAR        4  /* A-N Advertisement Register               */
289 #define MII_REG_ANLPAR      5  /* A-N Link Partner Ability Register        */
290 #define MII_REG_ANER        6  /* A-N Expansion Register                   */
291 #define MII_REG_ANNPTR      7  /* A-N Next Page Transmit Register          */
292 #define MII_REG_ANLPRNPR    8  /* A-N Link Partner Received Next Page Reg. */
293
294 /* values for phy_status */
295
296 #define PHY_CONF_ANE    0x0001  /* 1 auto-negotiation enabled */
297 #define PHY_CONF_LOOP   0x0002  /* 1 loopback mode enabled */
298 #define PHY_CONF_SPMASK 0x00f0  /* mask for speed */
299 #define PHY_CONF_10HDX  0x0010  /* 10 Mbit half duplex supported */
300 #define PHY_CONF_10FDX  0x0020  /* 10 Mbit full duplex supported */
301 #define PHY_CONF_100HDX 0x0040  /* 100 Mbit half duplex supported */
302 #define PHY_CONF_100FDX 0x0080  /* 100 Mbit full duplex supported */
303
304 #define PHY_STAT_LINK   0x0100  /* 1 up - 0 down */
305 #define PHY_STAT_FAULT  0x0200  /* 1 remote fault */
306 #define PHY_STAT_ANC    0x0400  /* 1 auto-negotiation complete  */
307 #define PHY_STAT_SPMASK 0xf000  /* mask for speed */
308 #define PHY_STAT_10HDX  0x1000  /* 10 Mbit half duplex selected */
309 #define PHY_STAT_10FDX  0x2000  /* 10 Mbit full duplex selected */
310 #define PHY_STAT_100HDX 0x4000  /* 100 Mbit half duplex selected */
311 #define PHY_STAT_100FDX 0x8000  /* 100 Mbit full duplex selected */
312
313
314 static int
315 fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
316 {
317         struct fec_enet_private *fep;
318         volatile fec_t  *fecp;
319         volatile cbd_t  *bdp;
320         unsigned short  status;
321         unsigned long flags;
322
323         fep = netdev_priv(dev);
324         fecp = (volatile fec_t*)dev->base_addr;
325
326         if (!fep->link) {
327                 /* Link is down or autonegotiation is in progress. */
328                 return 1;
329         }
330
331         spin_lock_irqsave(&fep->hw_lock, flags);
332         /* Fill in a Tx ring entry */
333         bdp = fep->cur_tx;
334
335         status = bdp->cbd_sc;
336 #ifndef final_version
337         if (status & BD_ENET_TX_READY) {
338                 /* Ooops.  All transmit buffers are full.  Bail out.
339                  * This should not happen, since dev->tbusy should be set.
340                  */
341                 printk("%s: tx queue full!.\n", dev->name);
342                 spin_unlock_irqrestore(&fep->hw_lock, flags);
343                 return 1;
344         }
345 #endif
346
347         /* Clear all of the status flags.
348          */
349         status &= ~BD_ENET_TX_STATS;
350
351         /* Set buffer length and buffer pointer.
352         */
353         bdp->cbd_bufaddr = __pa(skb->data);
354         bdp->cbd_datlen = skb->len;
355
356         /*
357          *      On some FEC implementations data must be aligned on
358          *      4-byte boundaries. Use bounce buffers to copy data
359          *      and get it aligned. Ugh.
360          */
361         if (bdp->cbd_bufaddr & FEC_ALIGNMENT) {
362                 unsigned int index;
363                 index = bdp - fep->tx_bd_base;
364                 memcpy(fep->tx_bounce[index], (void *)skb->data, skb->len);
365                 bdp->cbd_bufaddr = __pa(fep->tx_bounce[index]);
366         }
367
368         /* Save skb pointer.
369         */
370         fep->tx_skbuff[fep->skb_cur] = skb;
371
372         dev->stats.tx_bytes += skb->len;
373         fep->skb_cur = (fep->skb_cur+1) & TX_RING_MOD_MASK;
374
375         /* Push the data cache so the CPM does not get stale memory
376          * data.
377          */
378         dma_sync_single(NULL, bdp->cbd_bufaddr,
379                         bdp->cbd_datlen, DMA_TO_DEVICE);
380
381         /* Send it on its way.  Tell FEC it's ready, interrupt when done,
382          * it's the last BD of the frame, and to put the CRC on the end.
383          */
384
385         status |= (BD_ENET_TX_READY | BD_ENET_TX_INTR
386                         | BD_ENET_TX_LAST | BD_ENET_TX_TC);
387         bdp->cbd_sc = status;
388
389         dev->trans_start = jiffies;
390
391         /* Trigger transmission start */
392         fecp->fec_x_des_active = 0;
393
394         /* If this was the last BD in the ring, start at the beginning again.
395         */
396         if (status & BD_ENET_TX_WRAP) {
397                 bdp = fep->tx_bd_base;
398         } else {
399                 bdp++;
400         }
401
402         if (bdp == fep->dirty_tx) {
403                 fep->tx_full = 1;
404                 netif_stop_queue(dev);
405         }
406
407         fep->cur_tx = (cbd_t *)bdp;
408
409         spin_unlock_irqrestore(&fep->hw_lock, flags);
410
411         return 0;
412 }
413
414 static void
415 fec_timeout(struct net_device *dev)
416 {
417         struct fec_enet_private *fep = netdev_priv(dev);
418
419         printk("%s: transmit timed out.\n", dev->name);
420         dev->stats.tx_errors++;
421 #ifndef final_version
422         {
423         int     i;
424         cbd_t   *bdp;
425
426         printk("Ring data dump: cur_tx %lx%s, dirty_tx %lx cur_rx: %lx\n",
427                (unsigned long)fep->cur_tx, fep->tx_full ? " (full)" : "",
428                (unsigned long)fep->dirty_tx,
429                (unsigned long)fep->cur_rx);
430
431         bdp = fep->tx_bd_base;
432         printk(" tx: %u buffers\n",  TX_RING_SIZE);
433         for (i = 0 ; i < TX_RING_SIZE; i++) {
434                 printk("  %08x: %04x %04x %08x\n",
435                        (uint) bdp,
436                        bdp->cbd_sc,
437                        bdp->cbd_datlen,
438                        (int) bdp->cbd_bufaddr);
439                 bdp++;
440         }
441
442         bdp = fep->rx_bd_base;
443         printk(" rx: %lu buffers\n",  (unsigned long) RX_RING_SIZE);
444         for (i = 0 ; i < RX_RING_SIZE; i++) {
445                 printk("  %08x: %04x %04x %08x\n",
446                        (uint) bdp,
447                        bdp->cbd_sc,
448                        bdp->cbd_datlen,
449                        (int) bdp->cbd_bufaddr);
450                 bdp++;
451         }
452         }
453 #endif
454         fec_restart(dev, fep->full_duplex);
455         netif_wake_queue(dev);
456 }
457
458 /* The interrupt handler.
459  * This is called from the MPC core interrupt.
460  */
461 static irqreturn_t
462 fec_enet_interrupt(int irq, void * dev_id)
463 {
464         struct  net_device *dev = dev_id;
465         volatile fec_t  *fecp;
466         uint    int_events;
467         irqreturn_t ret = IRQ_NONE;
468
469         fecp = (volatile fec_t*)dev->base_addr;
470
471         /* Get the interrupt events that caused us to be here.
472         */
473         do {
474                 int_events = fecp->fec_ievent;
475                 fecp->fec_ievent = int_events;
476
477                 /* Handle receive event in its own function.
478                  */
479                 if (int_events & FEC_ENET_RXF) {
480                         ret = IRQ_HANDLED;
481                         fec_enet_rx(dev);
482                 }
483
484                 /* Transmit OK, or non-fatal error. Update the buffer
485                    descriptors. FEC handles all errors, we just discover
486                    them as part of the transmit process.
487                 */
488                 if (int_events & FEC_ENET_TXF) {
489                         ret = IRQ_HANDLED;
490                         fec_enet_tx(dev);
491                 }
492
493                 if (int_events & FEC_ENET_MII) {
494                         ret = IRQ_HANDLED;
495                         fec_enet_mii(dev);
496                 }
497
498         } while (int_events);
499
500         return ret;
501 }
502
503
504 static void
505 fec_enet_tx(struct net_device *dev)
506 {
507         struct  fec_enet_private *fep;
508         volatile cbd_t  *bdp;
509         unsigned short status;
510         struct  sk_buff *skb;
511
512         fep = netdev_priv(dev);
513         spin_lock_irq(&fep->hw_lock);
514         bdp = fep->dirty_tx;
515
516         while (((status = bdp->cbd_sc) & BD_ENET_TX_READY) == 0) {
517                 if (bdp == fep->cur_tx && fep->tx_full == 0) break;
518
519                 skb = fep->tx_skbuff[fep->skb_dirty];
520                 /* Check for errors. */
521                 if (status & (BD_ENET_TX_HB | BD_ENET_TX_LC |
522                                    BD_ENET_TX_RL | BD_ENET_TX_UN |
523                                    BD_ENET_TX_CSL)) {
524                         dev->stats.tx_errors++;
525                         if (status & BD_ENET_TX_HB)  /* No heartbeat */
526                                 dev->stats.tx_heartbeat_errors++;
527                         if (status & BD_ENET_TX_LC)  /* Late collision */
528                                 dev->stats.tx_window_errors++;
529                         if (status & BD_ENET_TX_RL)  /* Retrans limit */
530                                 dev->stats.tx_aborted_errors++;
531                         if (status & BD_ENET_TX_UN)  /* Underrun */
532                                 dev->stats.tx_fifo_errors++;
533                         if (status & BD_ENET_TX_CSL) /* Carrier lost */
534                                 dev->stats.tx_carrier_errors++;
535                 } else {
536                         dev->stats.tx_packets++;
537                 }
538
539 #ifndef final_version
540                 if (status & BD_ENET_TX_READY)
541                         printk("HEY! Enet xmit interrupt and TX_READY.\n");
542 #endif
543                 /* Deferred means some collisions occurred during transmit,
544                  * but we eventually sent the packet OK.
545                  */
546                 if (status & BD_ENET_TX_DEF)
547                         dev->stats.collisions++;
548
549                 /* Free the sk buffer associated with this last transmit.
550                  */
551                 dev_kfree_skb_any(skb);
552                 fep->tx_skbuff[fep->skb_dirty] = NULL;
553                 fep->skb_dirty = (fep->skb_dirty + 1) & TX_RING_MOD_MASK;
554
555                 /* Update pointer to next buffer descriptor to be transmitted.
556                  */
557                 if (status & BD_ENET_TX_WRAP)
558                         bdp = fep->tx_bd_base;
559                 else
560                         bdp++;
561
562                 /* Since we have freed up a buffer, the ring is no longer
563                  * full.
564                  */
565                 if (fep->tx_full) {
566                         fep->tx_full = 0;
567                         if (netif_queue_stopped(dev))
568                                 netif_wake_queue(dev);
569                 }
570         }
571         fep->dirty_tx = (cbd_t *)bdp;
572         spin_unlock_irq(&fep->hw_lock);
573 }
574
575
576 /* During a receive, the cur_rx points to the current incoming buffer.
577  * When we update through the ring, if the next incoming buffer has
578  * not been given to the system, we just set the empty indicator,
579  * effectively tossing the packet.
580  */
581 static void
582 fec_enet_rx(struct net_device *dev)
583 {
584         struct  fec_enet_private *fep;
585         volatile fec_t  *fecp;
586         volatile cbd_t *bdp;
587         unsigned short status;
588         struct  sk_buff *skb;
589         ushort  pkt_len;
590         __u8 *data;
591
592 #ifdef CONFIG_M532x
593         flush_cache_all();
594 #endif
595
596         fep = netdev_priv(dev);
597         fecp = (volatile fec_t*)dev->base_addr;
598
599         spin_lock_irq(&fep->hw_lock);
600
601         /* First, grab all of the stats for the incoming packet.
602          * These get messed up if we get called due to a busy condition.
603          */
604         bdp = fep->cur_rx;
605
606 while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) {
607
608 #ifndef final_version
609         /* Since we have allocated space to hold a complete frame,
610          * the last indicator should be set.
611          */
612         if ((status & BD_ENET_RX_LAST) == 0)
613                 printk("FEC ENET: rcv is not +last\n");
614 #endif
615
616         if (!fep->opened)
617                 goto rx_processing_done;
618
619         /* Check for errors. */
620         if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
621                            BD_ENET_RX_CR | BD_ENET_RX_OV)) {
622                 dev->stats.rx_errors++;
623                 if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH)) {
624                 /* Frame too long or too short. */
625                         dev->stats.rx_length_errors++;
626                 }
627                 if (status & BD_ENET_RX_NO)     /* Frame alignment */
628                         dev->stats.rx_frame_errors++;
629                 if (status & BD_ENET_RX_CR)     /* CRC Error */
630                         dev->stats.rx_crc_errors++;
631                 if (status & BD_ENET_RX_OV)     /* FIFO overrun */
632                         dev->stats.rx_fifo_errors++;
633         }
634
635         /* Report late collisions as a frame error.
636          * On this error, the BD is closed, but we don't know what we
637          * have in the buffer.  So, just drop this frame on the floor.
638          */
639         if (status & BD_ENET_RX_CL) {
640                 dev->stats.rx_errors++;
641                 dev->stats.rx_frame_errors++;
642                 goto rx_processing_done;
643         }
644
645         /* Process the incoming frame.
646          */
647         dev->stats.rx_packets++;
648         pkt_len = bdp->cbd_datlen;
649         dev->stats.rx_bytes += pkt_len;
650         data = (__u8*)__va(bdp->cbd_bufaddr);
651
652         dma_sync_single(NULL, (unsigned long)__pa(data),
653                         pkt_len - 4, DMA_FROM_DEVICE);
654
655         /* This does 16 byte alignment, exactly what we need.
656          * The packet length includes FCS, but we don't want to
657          * include that when passing upstream as it messes up
658          * bridging applications.
659          */
660         skb = dev_alloc_skb(pkt_len-4);
661
662         if (skb == NULL) {
663                 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
664                 dev->stats.rx_dropped++;
665         } else {
666                 skb_put(skb,pkt_len-4); /* Make room */
667                 skb_copy_to_linear_data(skb, data, pkt_len-4);
668                 skb->protocol=eth_type_trans(skb,dev);
669                 netif_rx(skb);
670         }
671   rx_processing_done:
672
673         /* Clear the status flags for this buffer.
674         */
675         status &= ~BD_ENET_RX_STATS;
676
677         /* Mark the buffer empty.
678         */
679         status |= BD_ENET_RX_EMPTY;
680         bdp->cbd_sc = status;
681
682         /* Update BD pointer to next entry.
683         */
684         if (status & BD_ENET_RX_WRAP)
685                 bdp = fep->rx_bd_base;
686         else
687                 bdp++;
688
689 #if 1
690         /* Doing this here will keep the FEC running while we process
691          * incoming frames.  On a heavily loaded network, we should be
692          * able to keep up at the expense of system resources.
693          */
694         fecp->fec_r_des_active = 0;
695 #endif
696    } /* while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) */
697         fep->cur_rx = (cbd_t *)bdp;
698
699 #if 0
700         /* Doing this here will allow us to process all frames in the
701          * ring before the FEC is allowed to put more there.  On a heavily
702          * loaded network, some frames may be lost.  Unfortunately, this
703          * increases the interrupt overhead since we can potentially work
704          * our way back to the interrupt return only to come right back
705          * here.
706          */
707         fecp->fec_r_des_active = 0;
708 #endif
709
710         spin_unlock_irq(&fep->hw_lock);
711 }
712
713
714 /* called from interrupt context */
715 static void
716 fec_enet_mii(struct net_device *dev)
717 {
718         struct  fec_enet_private *fep;
719         volatile fec_t  *ep;
720         mii_list_t      *mip;
721         uint            mii_reg;
722
723         fep = netdev_priv(dev);
724         spin_lock_irq(&fep->mii_lock);
725
726         ep = fep->hwp;
727         mii_reg = ep->fec_mii_data;
728
729         if ((mip = mii_head) == NULL) {
730                 printk("MII and no head!\n");
731                 goto unlock;
732         }
733
734         if (mip->mii_func != NULL)
735                 (*(mip->mii_func))(mii_reg, dev);
736
737         mii_head = mip->mii_next;
738         mip->mii_next = mii_free;
739         mii_free = mip;
740
741         if ((mip = mii_head) != NULL)
742                 ep->fec_mii_data = mip->mii_regval;
743
744 unlock:
745         spin_unlock_irq(&fep->mii_lock);
746 }
747
748 static int
749 mii_queue(struct net_device *dev, int regval, void (*func)(uint, struct net_device *))
750 {
751         struct fec_enet_private *fep;
752         unsigned long   flags;
753         mii_list_t      *mip;
754         int             retval;
755
756         /* Add PHY address to register command.
757         */
758         fep = netdev_priv(dev);
759         spin_lock_irqsave(&fep->mii_lock, flags);
760
761         regval |= fep->phy_addr << 23;
762         retval = 0;
763
764         if ((mip = mii_free) != NULL) {
765                 mii_free = mip->mii_next;
766                 mip->mii_regval = regval;
767                 mip->mii_func = func;
768                 mip->mii_next = NULL;
769                 if (mii_head) {
770                         mii_tail->mii_next = mip;
771                         mii_tail = mip;
772                 } else {
773                         mii_head = mii_tail = mip;
774                         fep->hwp->fec_mii_data = regval;
775                 }
776         } else {
777                 retval = 1;
778         }
779
780         spin_unlock_irqrestore(&fep->mii_lock, flags);
781         return retval;
782 }
783
784 static void mii_do_cmd(struct net_device *dev, const phy_cmd_t *c)
785 {
786         if(!c)
787                 return;
788
789         for (; c->mii_data != mk_mii_end; c++)
790                 mii_queue(dev, c->mii_data, c->funct);
791 }
792
793 static void mii_parse_sr(uint mii_reg, struct net_device *dev)
794 {
795         struct fec_enet_private *fep = netdev_priv(dev);
796         volatile uint *s = &(fep->phy_status);
797         uint status;
798
799         status = *s & ~(PHY_STAT_LINK | PHY_STAT_FAULT | PHY_STAT_ANC);
800
801         if (mii_reg & 0x0004)
802                 status |= PHY_STAT_LINK;
803         if (mii_reg & 0x0010)
804                 status |= PHY_STAT_FAULT;
805         if (mii_reg & 0x0020)
806                 status |= PHY_STAT_ANC;
807         *s = status;
808 }
809
810 static void mii_parse_cr(uint mii_reg, struct net_device *dev)
811 {
812         struct fec_enet_private *fep = netdev_priv(dev);
813         volatile uint *s = &(fep->phy_status);
814         uint status;
815
816         status = *s & ~(PHY_CONF_ANE | PHY_CONF_LOOP);
817
818         if (mii_reg & 0x1000)
819                 status |= PHY_CONF_ANE;
820         if (mii_reg & 0x4000)
821                 status |= PHY_CONF_LOOP;
822         *s = status;
823 }
824
825 static void mii_parse_anar(uint mii_reg, struct net_device *dev)
826 {
827         struct fec_enet_private *fep = netdev_priv(dev);
828         volatile uint *s = &(fep->phy_status);
829         uint status;
830
831         status = *s & ~(PHY_CONF_SPMASK);
832
833         if (mii_reg & 0x0020)
834                 status |= PHY_CONF_10HDX;
835         if (mii_reg & 0x0040)
836                 status |= PHY_CONF_10FDX;
837         if (mii_reg & 0x0080)
838                 status |= PHY_CONF_100HDX;
839         if (mii_reg & 0x00100)
840                 status |= PHY_CONF_100FDX;
841         *s = status;
842 }
843
844 /* ------------------------------------------------------------------------- */
845 /* The Level one LXT970 is used by many boards                               */
846
847 #define MII_LXT970_MIRROR    16  /* Mirror register           */
848 #define MII_LXT970_IER       17  /* Interrupt Enable Register */
849 #define MII_LXT970_ISR       18  /* Interrupt Status Register */
850 #define MII_LXT970_CONFIG    19  /* Configuration Register    */
851 #define MII_LXT970_CSR       20  /* Chip Status Register      */
852
853 static void mii_parse_lxt970_csr(uint mii_reg, struct net_device *dev)
854 {
855         struct fec_enet_private *fep = netdev_priv(dev);
856         volatile uint *s = &(fep->phy_status);
857         uint status;
858
859         status = *s & ~(PHY_STAT_SPMASK);
860         if (mii_reg & 0x0800) {
861                 if (mii_reg & 0x1000)
862                         status |= PHY_STAT_100FDX;
863                 else
864                         status |= PHY_STAT_100HDX;
865         } else {
866                 if (mii_reg & 0x1000)
867                         status |= PHY_STAT_10FDX;
868                 else
869                         status |= PHY_STAT_10HDX;
870         }
871         *s = status;
872 }
873
874 static phy_cmd_t const phy_cmd_lxt970_config[] = {
875                 { mk_mii_read(MII_REG_CR), mii_parse_cr },
876                 { mk_mii_read(MII_REG_ANAR), mii_parse_anar },
877                 { mk_mii_end, }
878         };
879 static phy_cmd_t const phy_cmd_lxt970_startup[] = { /* enable interrupts */
880                 { mk_mii_write(MII_LXT970_IER, 0x0002), NULL },
881                 { mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
882                 { mk_mii_end, }
883         };
884 static phy_cmd_t const phy_cmd_lxt970_ack_int[] = {
885                 /* read SR and ISR to acknowledge */
886                 { mk_mii_read(MII_REG_SR), mii_parse_sr },
887                 { mk_mii_read(MII_LXT970_ISR), NULL },
888
889                 /* find out the current status */
890                 { mk_mii_read(MII_LXT970_CSR), mii_parse_lxt970_csr },
891                 { mk_mii_end, }
892         };
893 static phy_cmd_t const phy_cmd_lxt970_shutdown[] = { /* disable interrupts */
894                 { mk_mii_write(MII_LXT970_IER, 0x0000), NULL },
895                 { mk_mii_end, }
896         };
897 static phy_info_t const phy_info_lxt970 = {
898         .id = 0x07810000,
899         .name = "LXT970",
900         .config = phy_cmd_lxt970_config,
901         .startup = phy_cmd_lxt970_startup,
902         .ack_int = phy_cmd_lxt970_ack_int,
903         .shutdown = phy_cmd_lxt970_shutdown
904 };
905
906 /* ------------------------------------------------------------------------- */
907 /* The Level one LXT971 is used on some of my custom boards                  */
908
909 /* register definitions for the 971 */
910
911 #define MII_LXT971_PCR       16  /* Port Control Register     */
912 #define MII_LXT971_SR2       17  /* Status Register 2         */
913 #define MII_LXT971_IER       18  /* Interrupt Enable Register */
914 #define MII_LXT971_ISR       19  /* Interrupt Status Register */
915 #define MII_LXT971_LCR       20  /* LED Control Register      */
916 #define MII_LXT971_TCR       30  /* Transmit Control Register */
917
918 /*
919  * I had some nice ideas of running the MDIO faster...
920  * The 971 should support 8MHz and I tried it, but things acted really
921  * weird, so 2.5 MHz ought to be enough for anyone...
922  */
923
924 static void mii_parse_lxt971_sr2(uint mii_reg, struct net_device *dev)
925 {
926         struct fec_enet_private *fep = netdev_priv(dev);
927         volatile uint *s = &(fep->phy_status);
928         uint status;
929
930         status = *s & ~(PHY_STAT_SPMASK | PHY_STAT_LINK | PHY_STAT_ANC);
931
932         if (mii_reg & 0x0400) {
933                 fep->link = 1;
934                 status |= PHY_STAT_LINK;
935         } else {
936                 fep->link = 0;
937         }
938         if (mii_reg & 0x0080)
939                 status |= PHY_STAT_ANC;
940         if (mii_reg & 0x4000) {
941                 if (mii_reg & 0x0200)
942                         status |= PHY_STAT_100FDX;
943                 else
944                         status |= PHY_STAT_100HDX;
945         } else {
946                 if (mii_reg & 0x0200)
947                         status |= PHY_STAT_10FDX;
948                 else
949                         status |= PHY_STAT_10HDX;
950         }
951         if (mii_reg & 0x0008)
952                 status |= PHY_STAT_FAULT;
953
954         *s = status;
955 }
956
957 static phy_cmd_t const phy_cmd_lxt971_config[] = {
958                 /* limit to 10MBit because my prototype board
959                  * doesn't work with 100. */
960                 { mk_mii_read(MII_REG_CR), mii_parse_cr },
961                 { mk_mii_read(MII_REG_ANAR), mii_parse_anar },
962                 { mk_mii_read(MII_LXT971_SR2), mii_parse_lxt971_sr2 },
963                 { mk_mii_end, }
964         };
965 static phy_cmd_t const phy_cmd_lxt971_startup[] = {  /* enable interrupts */
966                 { mk_mii_write(MII_LXT971_IER, 0x00f2), NULL },
967                 { mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
968                 { mk_mii_write(MII_LXT971_LCR, 0xd422), NULL }, /* LED config */
969                 /* Somehow does the 971 tell me that the link is down
970                  * the first read after power-up.
971                  * read here to get a valid value in ack_int */
972                 { mk_mii_read(MII_REG_SR), mii_parse_sr },
973                 { mk_mii_end, }
974         };
975 static phy_cmd_t const phy_cmd_lxt971_ack_int[] = {
976                 /* acknowledge the int before reading status ! */
977                 { mk_mii_read(MII_LXT971_ISR), NULL },
978                 /* find out the current status */
979                 { mk_mii_read(MII_REG_SR), mii_parse_sr },
980                 { mk_mii_read(MII_LXT971_SR2), mii_parse_lxt971_sr2 },
981                 { mk_mii_end, }
982         };
983 static phy_cmd_t const phy_cmd_lxt971_shutdown[] = { /* disable interrupts */
984                 { mk_mii_write(MII_LXT971_IER, 0x0000), NULL },
985                 { mk_mii_end, }
986         };
987 static phy_info_t const phy_info_lxt971 = {
988         .id = 0x0001378e,
989         .name = "LXT971",
990         .config = phy_cmd_lxt971_config,
991         .startup = phy_cmd_lxt971_startup,
992         .ack_int = phy_cmd_lxt971_ack_int,
993         .shutdown = phy_cmd_lxt971_shutdown
994 };
995
996 /* ------------------------------------------------------------------------- */
997 /* The Quality Semiconductor QS6612 is used on the RPX CLLF                  */
998
999 /* register definitions */
1000
1001 #define MII_QS6612_MCR       17  /* Mode Control Register      */
1002 #define MII_QS6612_FTR       27  /* Factory Test Register      */
1003 #define MII_QS6612_MCO       28  /* Misc. Control Register     */
1004 #define MII_QS6612_ISR       29  /* Interrupt Source Register  */
1005 #define MII_QS6612_IMR       30  /* Interrupt Mask Register    */
1006 #define MII_QS6612_PCR       31  /* 100BaseTx PHY Control Reg. */
1007
1008 static void mii_parse_qs6612_pcr(uint mii_reg, struct net_device *dev)
1009 {
1010         struct fec_enet_private *fep = netdev_priv(dev);
1011         volatile uint *s = &(fep->phy_status);
1012         uint status;
1013
1014         status = *s & ~(PHY_STAT_SPMASK);
1015
1016         switch((mii_reg >> 2) & 7) {
1017         case 1: status |= PHY_STAT_10HDX; break;
1018         case 2: status |= PHY_STAT_100HDX; break;
1019         case 5: status |= PHY_STAT_10FDX; break;
1020         case 6: status |= PHY_STAT_100FDX; break;
1021 }
1022
1023         *s = status;
1024 }
1025
1026 static phy_cmd_t const phy_cmd_qs6612_config[] = {
1027                 /* The PHY powers up isolated on the RPX,
1028                  * so send a command to allow operation.
1029                  */
1030                 { mk_mii_write(MII_QS6612_PCR, 0x0dc0), NULL },
1031
1032                 /* parse cr and anar to get some info */
1033                 { mk_mii_read(MII_REG_CR), mii_parse_cr },
1034                 { mk_mii_read(MII_REG_ANAR), mii_parse_anar },
1035                 { mk_mii_end, }
1036         };
1037 static phy_cmd_t const phy_cmd_qs6612_startup[] = {  /* enable interrupts */
1038                 { mk_mii_write(MII_QS6612_IMR, 0x003a), NULL },
1039                 { mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
1040                 { mk_mii_end, }
1041         };
1042 static phy_cmd_t const phy_cmd_qs6612_ack_int[] = {
1043                 /* we need to read ISR, SR and ANER to acknowledge */
1044                 { mk_mii_read(MII_QS6612_ISR), NULL },
1045                 { mk_mii_read(MII_REG_SR), mii_parse_sr },
1046                 { mk_mii_read(MII_REG_ANER), NULL },
1047
1048                 /* read pcr to get info */
1049                 { mk_mii_read(MII_QS6612_PCR), mii_parse_qs6612_pcr },
1050                 { mk_mii_end, }
1051         };
1052 static phy_cmd_t const phy_cmd_qs6612_shutdown[] = { /* disable interrupts */
1053                 { mk_mii_write(MII_QS6612_IMR, 0x0000), NULL },
1054                 { mk_mii_end, }
1055         };
1056 static phy_info_t const phy_info_qs6612 = {
1057         .id = 0x00181440,
1058         .name = "QS6612",
1059         .config = phy_cmd_qs6612_config,
1060         .startup = phy_cmd_qs6612_startup,
1061         .ack_int = phy_cmd_qs6612_ack_int,
1062         .shutdown = phy_cmd_qs6612_shutdown
1063 };
1064
1065 /* ------------------------------------------------------------------------- */
1066 /* AMD AM79C874 phy                                                          */
1067
1068 /* register definitions for the 874 */
1069
1070 #define MII_AM79C874_MFR       16  /* Miscellaneous Feature Register */
1071 #define MII_AM79C874_ICSR      17  /* Interrupt/Status Register      */
1072 #define MII_AM79C874_DR        18  /* Diagnostic Register            */
1073 #define MII_AM79C874_PMLR      19  /* Power and Loopback Register    */
1074 #define MII_AM79C874_MCR       21  /* ModeControl Register           */
1075 #define MII_AM79C874_DC        23  /* Disconnect Counter             */
1076 #define MII_AM79C874_REC       24  /* Recieve Error Counter          */
1077
1078 static void mii_parse_am79c874_dr(uint mii_reg, struct net_device *dev)
1079 {
1080         struct fec_enet_private *fep = netdev_priv(dev);
1081         volatile uint *s = &(fep->phy_status);
1082         uint status;
1083
1084         status = *s & ~(PHY_STAT_SPMASK | PHY_STAT_ANC);
1085
1086         if (mii_reg & 0x0080)
1087                 status |= PHY_STAT_ANC;
1088         if (mii_reg & 0x0400)
1089                 status |= ((mii_reg & 0x0800) ? PHY_STAT_100FDX : PHY_STAT_100HDX);
1090         else
1091                 status |= ((mii_reg & 0x0800) ? PHY_STAT_10FDX : PHY_STAT_10HDX);
1092
1093         *s = status;
1094 }
1095
1096 static phy_cmd_t const phy_cmd_am79c874_config[] = {
1097                 { mk_mii_read(MII_REG_CR), mii_parse_cr },
1098                 { mk_mii_read(MII_REG_ANAR), mii_parse_anar },
1099                 { mk_mii_read(MII_AM79C874_DR), mii_parse_am79c874_dr },
1100                 { mk_mii_end, }
1101         };
1102 static phy_cmd_t const phy_cmd_am79c874_startup[] = {  /* enable interrupts */
1103                 { mk_mii_write(MII_AM79C874_ICSR, 0xff00), NULL },
1104                 { mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
1105                 { mk_mii_read(MII_REG_SR), mii_parse_sr },
1106                 { mk_mii_end, }
1107         };
1108 static phy_cmd_t const phy_cmd_am79c874_ack_int[] = {
1109                 /* find out the current status */
1110                 { mk_mii_read(MII_REG_SR), mii_parse_sr },
1111                 { mk_mii_read(MII_AM79C874_DR), mii_parse_am79c874_dr },
1112                 /* we only need to read ISR to acknowledge */
1113                 { mk_mii_read(MII_AM79C874_ICSR), NULL },
1114                 { mk_mii_end, }
1115         };
1116 static phy_cmd_t const phy_cmd_am79c874_shutdown[] = { /* disable interrupts */
1117                 { mk_mii_write(MII_AM79C874_ICSR, 0x0000), NULL },
1118                 { mk_mii_end, }
1119         };
1120 static phy_info_t const phy_info_am79c874 = {
1121         .id = 0x00022561,
1122         .name = "AM79C874",
1123         .config = phy_cmd_am79c874_config,
1124         .startup = phy_cmd_am79c874_startup,
1125         .ack_int = phy_cmd_am79c874_ack_int,
1126         .shutdown = phy_cmd_am79c874_shutdown
1127 };
1128
1129
1130 /* ------------------------------------------------------------------------- */
1131 /* Kendin KS8721BL phy                                                       */
1132
1133 /* register definitions for the 8721 */
1134
1135 #define MII_KS8721BL_RXERCR     21
1136 #define MII_KS8721BL_ICSR       27
1137 #define MII_KS8721BL_PHYCR      31
1138
1139 static phy_cmd_t const phy_cmd_ks8721bl_config[] = {
1140                 { mk_mii_read(MII_REG_CR), mii_parse_cr },
1141                 { mk_mii_read(MII_REG_ANAR), mii_parse_anar },
1142                 { mk_mii_end, }
1143         };
1144 static phy_cmd_t const phy_cmd_ks8721bl_startup[] = {  /* enable interrupts */
1145                 { mk_mii_write(MII_KS8721BL_ICSR, 0xff00), NULL },
1146                 { mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
1147                 { mk_mii_read(MII_REG_SR), mii_parse_sr },
1148                 { mk_mii_end, }
1149         };
1150 static phy_cmd_t const phy_cmd_ks8721bl_ack_int[] = {
1151                 /* find out the current status */
1152                 { mk_mii_read(MII_REG_SR), mii_parse_sr },
1153                 /* we only need to read ISR to acknowledge */
1154                 { mk_mii_read(MII_KS8721BL_ICSR), NULL },
1155                 { mk_mii_end, }
1156         };
1157 static phy_cmd_t const phy_cmd_ks8721bl_shutdown[] = { /* disable interrupts */
1158                 { mk_mii_write(MII_KS8721BL_ICSR, 0x0000), NULL },
1159                 { mk_mii_end, }
1160         };
1161 static phy_info_t const phy_info_ks8721bl = {
1162         .id = 0x00022161,
1163         .name = "KS8721BL",
1164         .config = phy_cmd_ks8721bl_config,
1165         .startup = phy_cmd_ks8721bl_startup,
1166         .ack_int = phy_cmd_ks8721bl_ack_int,
1167         .shutdown = phy_cmd_ks8721bl_shutdown
1168 };
1169
1170 /* ------------------------------------------------------------------------- */
1171 /* register definitions for the DP83848 */
1172
1173 #define MII_DP8384X_PHYSTST    16  /* PHY Status Register */
1174
1175 static void mii_parse_dp8384x_sr2(uint mii_reg, struct net_device *dev)
1176 {
1177         struct fec_enet_private *fep = netdev_priv(dev);
1178         volatile uint *s = &(fep->phy_status);
1179
1180         *s &= ~(PHY_STAT_SPMASK | PHY_STAT_LINK | PHY_STAT_ANC);
1181
1182         /* Link up */
1183         if (mii_reg & 0x0001) {
1184                 fep->link = 1;
1185                 *s |= PHY_STAT_LINK;
1186         } else
1187                 fep->link = 0;
1188         /* Status of link */
1189         if (mii_reg & 0x0010)   /* Autonegotioation complete */
1190                 *s |= PHY_STAT_ANC;
1191         if (mii_reg & 0x0002) {   /* 10MBps? */
1192                 if (mii_reg & 0x0004)   /* Full Duplex? */
1193                         *s |= PHY_STAT_10FDX;
1194                 else
1195                         *s |= PHY_STAT_10HDX;
1196         } else {                  /* 100 Mbps? */
1197                 if (mii_reg & 0x0004)   /* Full Duplex? */
1198                         *s |= PHY_STAT_100FDX;
1199                 else
1200                         *s |= PHY_STAT_100HDX;
1201         }
1202         if (mii_reg & 0x0008)
1203                 *s |= PHY_STAT_FAULT;
1204 }
1205
1206 static phy_info_t phy_info_dp83848= {
1207         0x020005c9,
1208         "DP83848",
1209
1210         (const phy_cmd_t []) {  /* config */
1211                 { mk_mii_read(MII_REG_CR), mii_parse_cr },
1212                 { mk_mii_read(MII_REG_ANAR), mii_parse_anar },
1213                 { mk_mii_read(MII_DP8384X_PHYSTST), mii_parse_dp8384x_sr2 },
1214                 { mk_mii_end, }
1215         },
1216         (const phy_cmd_t []) {  /* startup - enable interrupts */
1217                 { mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
1218                 { mk_mii_read(MII_REG_SR), mii_parse_sr },
1219                 { mk_mii_end, }
1220         },
1221         (const phy_cmd_t []) { /* ack_int - never happens, no interrupt */
1222                 { mk_mii_end, }
1223         },
1224         (const phy_cmd_t []) {  /* shutdown */
1225                 { mk_mii_end, }
1226         },
1227 };
1228
1229 /* ------------------------------------------------------------------------- */
1230
1231 static phy_info_t const * const phy_info[] = {
1232         &phy_info_lxt970,
1233         &phy_info_lxt971,
1234         &phy_info_qs6612,
1235         &phy_info_am79c874,
1236         &phy_info_ks8721bl,
1237         &phy_info_dp83848,
1238         NULL
1239 };
1240
1241 /* ------------------------------------------------------------------------- */
1242 #ifdef HAVE_mii_link_interrupt
1243 static irqreturn_t
1244 mii_link_interrupt(int irq, void * dev_id);
1245 #endif
1246
1247 #if defined(CONFIG_M5272)
1248 /*
1249  *      Code specific to Coldfire 5272 setup.
1250  */
1251 static void __inline__ fec_request_intrs(struct net_device *dev)
1252 {
1253         volatile unsigned long *icrp;
1254         static const struct idesc {
1255                 char *name;
1256                 unsigned short irq;
1257                 irq_handler_t handler;
1258         } *idp, id[] = {
1259                 { "fec(RX)", 86, fec_enet_interrupt },
1260                 { "fec(TX)", 87, fec_enet_interrupt },
1261                 { "fec(OTHER)", 88, fec_enet_interrupt },
1262                 { "fec(MII)", 66, mii_link_interrupt },
1263                 { NULL },
1264         };
1265
1266         /* Setup interrupt handlers. */
1267         for (idp = id; idp->name; idp++) {
1268                 if (request_irq(idp->irq, idp->handler, IRQF_DISABLED, idp->name, dev) != 0)
1269                         printk("FEC: Could not allocate %s IRQ(%d)!\n", idp->name, idp->irq);
1270         }
1271
1272         /* Unmask interrupt at ColdFire 5272 SIM */
1273         icrp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_ICR3);
1274         *icrp = 0x00000ddd;
1275         icrp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_ICR1);
1276         *icrp = 0x0d000000;
1277 }
1278
1279 static void __inline__ fec_set_mii(struct net_device *dev, struct fec_enet_private *fep)
1280 {
1281         volatile fec_t *fecp;
1282
1283         fecp = fep->hwp;
1284         fecp->fec_r_cntrl = OPT_FRAME_SIZE | 0x04;
1285         fecp->fec_x_cntrl = 0x00;
1286
1287         /*
1288          * Set MII speed to 2.5 MHz
1289          * See 5272 manual section 11.5.8: MSCR
1290          */
1291         fep->phy_speed = ((((MCF_CLK / 4) / (2500000 / 10)) + 5) / 10) * 2;
1292         fecp->fec_mii_speed = fep->phy_speed;
1293
1294         fec_restart(dev, 0);
1295 }
1296
1297 static void __inline__ fec_get_mac(struct net_device *dev)
1298 {
1299         struct fec_enet_private *fep = netdev_priv(dev);
1300         volatile fec_t *fecp;
1301         unsigned char *iap, tmpaddr[ETH_ALEN];
1302
1303         fecp = fep->hwp;
1304
1305         if (FEC_FLASHMAC) {
1306                 /*
1307                  * Get MAC address from FLASH.
1308                  * If it is all 1's or 0's, use the default.
1309                  */
1310                 iap = (unsigned char *)FEC_FLASHMAC;
1311                 if ((iap[0] == 0) && (iap[1] == 0) && (iap[2] == 0) &&
1312                     (iap[3] == 0) && (iap[4] == 0) && (iap[5] == 0))
1313                         iap = fec_mac_default;
1314                 if ((iap[0] == 0xff) && (iap[1] == 0xff) && (iap[2] == 0xff) &&
1315                     (iap[3] == 0xff) && (iap[4] == 0xff) && (iap[5] == 0xff))
1316                         iap = fec_mac_default;
1317         } else {
1318                 *((unsigned long *) &tmpaddr[0]) = fecp->fec_addr_low;
1319                 *((unsigned short *) &tmpaddr[4]) = (fecp->fec_addr_high >> 16);
1320                 iap = &tmpaddr[0];
1321         }
1322
1323         memcpy(dev->dev_addr, iap, ETH_ALEN);
1324
1325         /* Adjust MAC if using default MAC address */
1326         if (iap == fec_mac_default)
1327                  dev->dev_addr[ETH_ALEN-1] = fec_mac_default[ETH_ALEN-1] + fep->index;
1328 }
1329
1330 static void __inline__ fec_disable_phy_intr(void)
1331 {
1332         volatile unsigned long *icrp;
1333         icrp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_ICR1);
1334         *icrp = 0x08000000;
1335 }
1336
1337 static void __inline__ fec_phy_ack_intr(void)
1338 {
1339         volatile unsigned long *icrp;
1340         /* Acknowledge the interrupt */
1341         icrp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_ICR1);
1342         *icrp = 0x0d000000;
1343 }
1344
1345 /* ------------------------------------------------------------------------- */
1346
1347 #elif defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x)
1348
1349 /*
1350  *      Code specific to Coldfire 5230/5231/5232/5234/5235,
1351  *      the 5270/5271/5274/5275 and 5280/5282 setups.
1352  */
1353 static void __inline__ fec_request_intrs(struct net_device *dev)
1354 {
1355         struct fec_enet_private *fep;
1356         int b;
1357         static const struct idesc {
1358                 char *name;
1359                 unsigned short irq;
1360         } *idp, id[] = {
1361                 { "fec(TXF)", 23 },
1362                 { "fec(RXF)", 27 },
1363                 { "fec(MII)", 29 },
1364                 { NULL },
1365         };
1366
1367         fep = netdev_priv(dev);
1368         b = (fep->index) ? 128 : 64;
1369
1370         /* Setup interrupt handlers. */
1371         for (idp = id; idp->name; idp++) {
1372                 if (request_irq(b+idp->irq, fec_enet_interrupt, IRQF_DISABLED, idp->name, dev) != 0)
1373                         printk("FEC: Could not allocate %s IRQ(%d)!\n", idp->name, b+idp->irq);
1374         }
1375
1376         /* Unmask interrupts at ColdFire 5280/5282 interrupt controller */
1377         {
1378                 volatile unsigned char  *icrp;
1379                 volatile unsigned long  *imrp;
1380                 int i, ilip;
1381
1382                 b = (fep->index) ? MCFICM_INTC1 : MCFICM_INTC0;
1383                 icrp = (volatile unsigned char *) (MCF_IPSBAR + b +
1384                         MCFINTC_ICR0);
1385                 for (i = 23, ilip = 0x28; (i < 36); i++)
1386                         icrp[i] = ilip--;
1387
1388                 imrp = (volatile unsigned long *) (MCF_IPSBAR + b +
1389                         MCFINTC_IMRH);
1390                 *imrp &= ~0x0000000f;
1391                 imrp = (volatile unsigned long *) (MCF_IPSBAR + b +
1392                         MCFINTC_IMRL);
1393                 *imrp &= ~0xff800001;
1394         }
1395
1396 #if defined(CONFIG_M528x)
1397         /* Set up gpio outputs for MII lines */
1398         {
1399                 volatile u16 *gpio_paspar;
1400                 volatile u8 *gpio_pehlpar;
1401
1402                 gpio_paspar = (volatile u16 *) (MCF_IPSBAR + 0x100056);
1403                 gpio_pehlpar = (volatile u16 *) (MCF_IPSBAR + 0x100058);
1404                 *gpio_paspar |= 0x0f00;
1405                 *gpio_pehlpar = 0xc0;
1406         }
1407 #endif
1408
1409 #if defined(CONFIG_M527x)
1410         /* Set up gpio outputs for MII lines */
1411         {
1412                 volatile u8 *gpio_par_fec;
1413                 volatile u16 *gpio_par_feci2c;
1414
1415                 gpio_par_feci2c = (volatile u16 *)(MCF_IPSBAR + 0x100082);
1416                 /* Set up gpio outputs for FEC0 MII lines */
1417                 gpio_par_fec = (volatile u8 *)(MCF_IPSBAR + 0x100078);
1418
1419                 *gpio_par_feci2c |= 0x0f00;
1420                 *gpio_par_fec |= 0xc0;
1421
1422 #if defined(CONFIG_FEC2)
1423                 /* Set up gpio outputs for FEC1 MII lines */
1424                 gpio_par_fec = (volatile u8 *)(MCF_IPSBAR + 0x100079);
1425
1426                 *gpio_par_feci2c |= 0x00a0;
1427                 *gpio_par_fec |= 0xc0;
1428 #endif /* CONFIG_FEC2 */
1429         }
1430 #endif /* CONFIG_M527x */
1431 }
1432
1433 static void __inline__ fec_set_mii(struct net_device *dev, struct fec_enet_private *fep)
1434 {
1435         volatile fec_t *fecp;
1436
1437         fecp = fep->hwp;
1438         fecp->fec_r_cntrl = OPT_FRAME_SIZE | 0x04;
1439         fecp->fec_x_cntrl = 0x00;
1440
1441         /*
1442          * Set MII speed to 2.5 MHz
1443          * See 5282 manual section 17.5.4.7: MSCR
1444          */
1445         fep->phy_speed = ((((MCF_CLK / 2) / (2500000 / 10)) + 5) / 10) * 2;
1446         fecp->fec_mii_speed = fep->phy_speed;
1447
1448         fec_restart(dev, 0);
1449 }
1450
1451 static void __inline__ fec_get_mac(struct net_device *dev)
1452 {
1453         struct fec_enet_private *fep = netdev_priv(dev);
1454         volatile fec_t *fecp;
1455         unsigned char *iap, tmpaddr[ETH_ALEN];
1456
1457         fecp = fep->hwp;
1458
1459         if (FEC_FLASHMAC) {
1460                 /*
1461                  * Get MAC address from FLASH.
1462                  * If it is all 1's or 0's, use the default.
1463                  */
1464                 iap = FEC_FLASHMAC;
1465                 if ((iap[0] == 0) && (iap[1] == 0) && (iap[2] == 0) &&
1466                     (iap[3] == 0) && (iap[4] == 0) && (iap[5] == 0))
1467                         iap = fec_mac_default;
1468                 if ((iap[0] == 0xff) && (iap[1] == 0xff) && (iap[2] == 0xff) &&
1469                     (iap[3] == 0xff) && (iap[4] == 0xff) && (iap[5] == 0xff))
1470                         iap = fec_mac_default;
1471         } else {
1472                 *((unsigned long *) &tmpaddr[0]) = fecp->fec_addr_low;
1473                 *((unsigned short *) &tmpaddr[4]) = (fecp->fec_addr_high >> 16);
1474                 iap = &tmpaddr[0];
1475         }
1476
1477         memcpy(dev->dev_addr, iap, ETH_ALEN);
1478
1479         /* Adjust MAC if using default MAC address */
1480         if (iap == fec_mac_default)
1481                 dev->dev_addr[ETH_ALEN-1] = fec_mac_default[ETH_ALEN-1] + fep->index;
1482 }
1483
1484 static void __inline__ fec_disable_phy_intr(void)
1485 {
1486 }
1487
1488 static void __inline__ fec_phy_ack_intr(void)
1489 {
1490 }
1491
1492 /* ------------------------------------------------------------------------- */
1493
1494 #elif defined(CONFIG_M520x)
1495
1496 /*
1497  *      Code specific to Coldfire 520x
1498  */
1499 static void __inline__ fec_request_intrs(struct net_device *dev)
1500 {
1501         struct fec_enet_private *fep;
1502         int b;
1503         static const struct idesc {
1504                 char *name;
1505                 unsigned short irq;
1506         } *idp, id[] = {
1507                 { "fec(TXF)", 23 },
1508                 { "fec(RXF)", 27 },
1509                 { "fec(MII)", 29 },
1510                 { NULL },
1511         };
1512
1513         fep = netdev_priv(dev);
1514         b = 64 + 13;
1515
1516         /* Setup interrupt handlers. */
1517         for (idp = id; idp->name; idp++) {
1518                 if (request_irq(b+idp->irq, fec_enet_interrupt, IRQF_DISABLED, idp->name,dev) != 0)
1519                         printk("FEC: Could not allocate %s IRQ(%d)!\n", idp->name, b+idp->irq);
1520         }
1521
1522         /* Unmask interrupts at ColdFire interrupt controller */
1523         {
1524                 volatile unsigned char  *icrp;
1525                 volatile unsigned long  *imrp;
1526
1527                 icrp = (volatile unsigned char *) (MCF_IPSBAR + MCFICM_INTC0 +
1528                         MCFINTC_ICR0);
1529                 for (b = 36; (b < 49); b++)
1530                         icrp[b] = 0x04;
1531                 imrp = (volatile unsigned long *) (MCF_IPSBAR + MCFICM_INTC0 +
1532                         MCFINTC_IMRH);
1533                 *imrp &= ~0x0001FFF0;
1534         }
1535         *(volatile unsigned char *)(MCF_IPSBAR + MCF_GPIO_PAR_FEC) |= 0xf0;
1536         *(volatile unsigned char *)(MCF_IPSBAR + MCF_GPIO_PAR_FECI2C) |= 0x0f;
1537 }
1538
1539 static void __inline__ fec_set_mii(struct net_device *dev, struct fec_enet_private *fep)
1540 {
1541         volatile fec_t *fecp;
1542
1543         fecp = fep->hwp;
1544         fecp->fec_r_cntrl = OPT_FRAME_SIZE | 0x04;
1545         fecp->fec_x_cntrl = 0x00;
1546
1547         /*
1548          * Set MII speed to 2.5 MHz
1549          * See 5282 manual section 17.5.4.7: MSCR
1550          */
1551         fep->phy_speed = ((((MCF_CLK / 2) / (2500000 / 10)) + 5) / 10) * 2;
1552         fecp->fec_mii_speed = fep->phy_speed;
1553
1554         fec_restart(dev, 0);
1555 }
1556
1557 static void __inline__ fec_get_mac(struct net_device *dev)
1558 {
1559         struct fec_enet_private *fep = netdev_priv(dev);
1560         volatile fec_t *fecp;
1561         unsigned char *iap, tmpaddr[ETH_ALEN];
1562
1563         fecp = fep->hwp;
1564
1565         if (FEC_FLASHMAC) {
1566                 /*
1567                  * Get MAC address from FLASH.
1568                  * If it is all 1's or 0's, use the default.
1569                  */
1570                 iap = FEC_FLASHMAC;
1571                 if ((iap[0] == 0) && (iap[1] == 0) && (iap[2] == 0) &&
1572                    (iap[3] == 0) && (iap[4] == 0) && (iap[5] == 0))
1573                         iap = fec_mac_default;
1574                 if ((iap[0] == 0xff) && (iap[1] == 0xff) && (iap[2] == 0xff) &&
1575                    (iap[3] == 0xff) && (iap[4] == 0xff) && (iap[5] == 0xff))
1576                         iap = fec_mac_default;
1577         } else {
1578                 *((unsigned long *) &tmpaddr[0]) = fecp->fec_addr_low;
1579                 *((unsigned short *) &tmpaddr[4]) = (fecp->fec_addr_high >> 16);
1580                 iap = &tmpaddr[0];
1581         }
1582
1583         memcpy(dev->dev_addr, iap, ETH_ALEN);
1584
1585         /* Adjust MAC if using default MAC address */
1586         if (iap == fec_mac_default)
1587                 dev->dev_addr[ETH_ALEN-1] = fec_mac_default[ETH_ALEN-1] + fep->index;
1588 }
1589
1590 static void __inline__ fec_disable_phy_intr(void)
1591 {
1592 }
1593
1594 static void __inline__ fec_phy_ack_intr(void)
1595 {
1596 }
1597
1598 /* ------------------------------------------------------------------------- */
1599
1600 #elif defined(CONFIG_M532x)
1601 /*
1602  * Code specific for M532x
1603  */
1604 static void __inline__ fec_request_intrs(struct net_device *dev)
1605 {
1606         struct fec_enet_private *fep;
1607         int b;
1608         static const struct idesc {
1609                 char *name;
1610                 unsigned short irq;
1611         } *idp, id[] = {
1612             { "fec(TXF)", 36 },
1613             { "fec(RXF)", 40 },
1614             { "fec(MII)", 42 },
1615             { NULL },
1616         };
1617
1618         fep = netdev_priv(dev);
1619         b = (fep->index) ? 128 : 64;
1620
1621         /* Setup interrupt handlers. */
1622         for (idp = id; idp->name; idp++) {
1623                 if (request_irq(b+idp->irq, fec_enet_interrupt, IRQF_DISABLED, idp->name,dev) != 0)
1624                         printk("FEC: Could not allocate %s IRQ(%d)!\n",
1625                                 idp->name, b+idp->irq);
1626         }
1627
1628         /* Unmask interrupts */
1629         MCF_INTC0_ICR36 = 0x2;
1630         MCF_INTC0_ICR37 = 0x2;
1631         MCF_INTC0_ICR38 = 0x2;
1632         MCF_INTC0_ICR39 = 0x2;
1633         MCF_INTC0_ICR40 = 0x2;
1634         MCF_INTC0_ICR41 = 0x2;
1635         MCF_INTC0_ICR42 = 0x2;
1636         MCF_INTC0_ICR43 = 0x2;
1637         MCF_INTC0_ICR44 = 0x2;
1638         MCF_INTC0_ICR45 = 0x2;
1639         MCF_INTC0_ICR46 = 0x2;
1640         MCF_INTC0_ICR47 = 0x2;
1641         MCF_INTC0_ICR48 = 0x2;
1642
1643         MCF_INTC0_IMRH &= ~(
1644                 MCF_INTC_IMRH_INT_MASK36 |
1645                 MCF_INTC_IMRH_INT_MASK37 |
1646                 MCF_INTC_IMRH_INT_MASK38 |
1647                 MCF_INTC_IMRH_INT_MASK39 |
1648                 MCF_INTC_IMRH_INT_MASK40 |
1649                 MCF_INTC_IMRH_INT_MASK41 |
1650                 MCF_INTC_IMRH_INT_MASK42 |
1651                 MCF_INTC_IMRH_INT_MASK43 |
1652                 MCF_INTC_IMRH_INT_MASK44 |
1653                 MCF_INTC_IMRH_INT_MASK45 |
1654                 MCF_INTC_IMRH_INT_MASK46 |
1655                 MCF_INTC_IMRH_INT_MASK47 |
1656                 MCF_INTC_IMRH_INT_MASK48 );
1657
1658         /* Set up gpio outputs for MII lines */
1659         MCF_GPIO_PAR_FECI2C |= (0 |
1660                 MCF_GPIO_PAR_FECI2C_PAR_MDC_EMDC |
1661                 MCF_GPIO_PAR_FECI2C_PAR_MDIO_EMDIO);
1662         MCF_GPIO_PAR_FEC = (0 |
1663                 MCF_GPIO_PAR_FEC_PAR_FEC_7W_FEC |
1664                 MCF_GPIO_PAR_FEC_PAR_FEC_MII_FEC);
1665 }
1666
1667 static void __inline__ fec_set_mii(struct net_device *dev, struct fec_enet_private *fep)
1668 {
1669         volatile fec_t *fecp;
1670
1671         fecp = fep->hwp;
1672         fecp->fec_r_cntrl = OPT_FRAME_SIZE | 0x04;
1673         fecp->fec_x_cntrl = 0x00;
1674
1675         /*
1676          * Set MII speed to 2.5 MHz
1677          */
1678         fep->phy_speed = (MCF_CLK / 3) / (2500000 * 2 ) * 2;
1679         fecp->fec_mii_speed = fep->phy_speed;
1680
1681         fec_restart(dev, 0);
1682 }
1683
1684 static void __inline__ fec_get_mac(struct net_device *dev)
1685 {
1686         struct fec_enet_private *fep = netdev_priv(dev);
1687         volatile fec_t *fecp;
1688         unsigned char *iap, tmpaddr[ETH_ALEN];
1689
1690         fecp = fep->hwp;
1691
1692         if (FEC_FLASHMAC) {
1693                 /*
1694                  * Get MAC address from FLASH.
1695                  * If it is all 1's or 0's, use the default.
1696                  */
1697                 iap = FEC_FLASHMAC;
1698                 if ((iap[0] == 0) && (iap[1] == 0) && (iap[2] == 0) &&
1699                     (iap[3] == 0) && (iap[4] == 0) && (iap[5] == 0))
1700                         iap = fec_mac_default;
1701                 if ((iap[0] == 0xff) && (iap[1] == 0xff) && (iap[2] == 0xff) &&
1702                     (iap[3] == 0xff) && (iap[4] == 0xff) && (iap[5] == 0xff))
1703                         iap = fec_mac_default;
1704         } else {
1705                 *((unsigned long *) &tmpaddr[0]) = fecp->fec_addr_low;
1706                 *((unsigned short *) &tmpaddr[4]) = (fecp->fec_addr_high >> 16);
1707                 iap = &tmpaddr[0];
1708         }
1709
1710         memcpy(dev->dev_addr, iap, ETH_ALEN);
1711
1712         /* Adjust MAC if using default MAC address */
1713         if (iap == fec_mac_default)
1714                 dev->dev_addr[ETH_ALEN-1] = fec_mac_default[ETH_ALEN-1] + fep->index;
1715 }
1716
1717 static void __inline__ fec_disable_phy_intr(void)
1718 {
1719 }
1720
1721 static void __inline__ fec_phy_ack_intr(void)
1722 {
1723 }
1724
1725 #endif
1726
1727 /* ------------------------------------------------------------------------- */
1728
1729 static void mii_display_status(struct net_device *dev)
1730 {
1731         struct fec_enet_private *fep = netdev_priv(dev);
1732         volatile uint *s = &(fep->phy_status);
1733
1734         if (!fep->link && !fep->old_link) {
1735                 /* Link is still down - don't print anything */
1736                 return;
1737         }
1738
1739         printk("%s: status: ", dev->name);
1740
1741         if (!fep->link) {
1742                 printk("link down");
1743         } else {
1744                 printk("link up");
1745
1746                 switch(*s & PHY_STAT_SPMASK) {
1747                 case PHY_STAT_100FDX: printk(", 100MBit Full Duplex"); break;
1748                 case PHY_STAT_100HDX: printk(", 100MBit Half Duplex"); break;
1749                 case PHY_STAT_10FDX: printk(", 10MBit Full Duplex"); break;
1750                 case PHY_STAT_10HDX: printk(", 10MBit Half Duplex"); break;
1751                 default:
1752                         printk(", Unknown speed/duplex");
1753                 }
1754
1755                 if (*s & PHY_STAT_ANC)
1756                         printk(", auto-negotiation complete");
1757         }
1758
1759         if (*s & PHY_STAT_FAULT)
1760                 printk(", remote fault");
1761
1762         printk(".\n");
1763 }
1764
1765 static void mii_display_config(struct work_struct *work)
1766 {
1767         struct fec_enet_private *fep = container_of(work, struct fec_enet_private, phy_task);
1768         struct net_device *dev = fep->netdev;
1769         uint status = fep->phy_status;
1770
1771         /*
1772         ** When we get here, phy_task is already removed from
1773         ** the workqueue.  It is thus safe to allow to reuse it.
1774         */
1775         fep->mii_phy_task_queued = 0;
1776         printk("%s: config: auto-negotiation ", dev->name);
1777
1778         if (status & PHY_CONF_ANE)
1779                 printk("on");
1780         else
1781                 printk("off");
1782
1783         if (status & PHY_CONF_100FDX)
1784                 printk(", 100FDX");
1785         if (status & PHY_CONF_100HDX)
1786                 printk(", 100HDX");
1787         if (status & PHY_CONF_10FDX)
1788                 printk(", 10FDX");
1789         if (status & PHY_CONF_10HDX)
1790                 printk(", 10HDX");
1791         if (!(status & PHY_CONF_SPMASK))
1792                 printk(", No speed/duplex selected?");
1793
1794         if (status & PHY_CONF_LOOP)
1795                 printk(", loopback enabled");
1796
1797         printk(".\n");
1798
1799         fep->sequence_done = 1;
1800 }
1801
1802 static void mii_relink(struct work_struct *work)
1803 {
1804         struct fec_enet_private *fep = container_of(work, struct fec_enet_private, phy_task);
1805         struct net_device *dev = fep->netdev;
1806         int duplex;
1807
1808         /*
1809         ** When we get here, phy_task is already removed from
1810         ** the workqueue.  It is thus safe to allow to reuse it.
1811         */
1812         fep->mii_phy_task_queued = 0;
1813         fep->link = (fep->phy_status & PHY_STAT_LINK) ? 1 : 0;
1814         mii_display_status(dev);
1815         fep->old_link = fep->link;
1816
1817         if (fep->link) {
1818                 duplex = 0;
1819                 if (fep->phy_status
1820                     & (PHY_STAT_100FDX | PHY_STAT_10FDX))
1821                         duplex = 1;
1822                 fec_restart(dev, duplex);
1823         } else
1824                 fec_stop(dev);
1825
1826 #if 0
1827         enable_irq(fep->mii_irq);
1828 #endif
1829
1830 }
1831
1832 /* mii_queue_relink is called in interrupt context from mii_link_interrupt */
1833 static void mii_queue_relink(uint mii_reg, struct net_device *dev)
1834 {
1835         struct fec_enet_private *fep = netdev_priv(dev);
1836
1837         /*
1838         ** We cannot queue phy_task twice in the workqueue.  It
1839         ** would cause an endless loop in the workqueue.
1840         ** Fortunately, if the last mii_relink entry has not yet been
1841         ** executed now, it will do the job for the current interrupt,
1842         ** which is just what we want.
1843         */
1844         if (fep->mii_phy_task_queued)
1845                 return;
1846
1847         fep->mii_phy_task_queued = 1;
1848         INIT_WORK(&fep->phy_task, mii_relink);
1849         schedule_work(&fep->phy_task);
1850 }
1851
1852 /* mii_queue_config is called in interrupt context from fec_enet_mii */
1853 static void mii_queue_config(uint mii_reg, struct net_device *dev)
1854 {
1855         struct fec_enet_private *fep = netdev_priv(dev);
1856
1857         if (fep->mii_phy_task_queued)
1858                 return;
1859
1860         fep->mii_phy_task_queued = 1;
1861         INIT_WORK(&fep->phy_task, mii_display_config);
1862         schedule_work(&fep->phy_task);
1863 }
1864
1865 phy_cmd_t const phy_cmd_relink[] = {
1866         { mk_mii_read(MII_REG_CR), mii_queue_relink },
1867         { mk_mii_end, }
1868         };
1869 phy_cmd_t const phy_cmd_config[] = {
1870         { mk_mii_read(MII_REG_CR), mii_queue_config },
1871         { mk_mii_end, }
1872         };
1873
1874 /* Read remainder of PHY ID.
1875 */
1876 static void
1877 mii_discover_phy3(uint mii_reg, struct net_device *dev)
1878 {
1879         struct fec_enet_private *fep;
1880         int i;
1881
1882         fep = netdev_priv(dev);
1883         fep->phy_id |= (mii_reg & 0xffff);
1884         printk("fec: PHY @ 0x%x, ID 0x%08x", fep->phy_addr, fep->phy_id);
1885
1886         for(i = 0; phy_info[i]; i++) {
1887                 if(phy_info[i]->id == (fep->phy_id >> 4))
1888                         break;
1889         }
1890
1891         if (phy_info[i])
1892                 printk(" -- %s\n", phy_info[i]->name);
1893         else
1894                 printk(" -- unknown PHY!\n");
1895
1896         fep->phy = phy_info[i];
1897         fep->phy_id_done = 1;
1898 }
1899
1900 /* Scan all of the MII PHY addresses looking for someone to respond
1901  * with a valid ID.  This usually happens quickly.
1902  */
1903 static void
1904 mii_discover_phy(uint mii_reg, struct net_device *dev)
1905 {
1906         struct fec_enet_private *fep;
1907         volatile fec_t *fecp;
1908         uint phytype;
1909
1910         fep = netdev_priv(dev);
1911         fecp = fep->hwp;
1912
1913         if (fep->phy_addr < 32) {
1914                 if ((phytype = (mii_reg & 0xffff)) != 0xffff && phytype != 0) {
1915
1916                         /* Got first part of ID, now get remainder.
1917                         */
1918                         fep->phy_id = phytype << 16;
1919                         mii_queue(dev, mk_mii_read(MII_REG_PHYIR2),
1920                                                         mii_discover_phy3);
1921                 } else {
1922                         fep->phy_addr++;
1923                         mii_queue(dev, mk_mii_read(MII_REG_PHYIR1),
1924                                                         mii_discover_phy);
1925                 }
1926         } else {
1927                 printk("FEC: No PHY device found.\n");
1928                 /* Disable external MII interface */
1929                 fecp->fec_mii_speed = fep->phy_speed = 0;
1930 #ifdef FREC_LEGACY
1931                 fec_disable_phy_intr();
1932 #endif
1933         }
1934 }
1935
1936 /* This interrupt occurs when the PHY detects a link change.
1937 */
1938 #ifdef HAVE_mii_link_interrupt
1939 static irqreturn_t
1940 mii_link_interrupt(int irq, void * dev_id)
1941 {
1942         struct  net_device *dev = dev_id;
1943         struct fec_enet_private *fep = netdev_priv(dev);
1944
1945         fec_phy_ack_intr();
1946
1947 #if 0
1948         disable_irq(fep->mii_irq);  /* disable now, enable later */
1949 #endif
1950
1951         mii_do_cmd(dev, fep->phy->ack_int);
1952         mii_do_cmd(dev, phy_cmd_relink);  /* restart and display status */
1953
1954         return IRQ_HANDLED;
1955 }
1956 #endif
1957
1958 static int
1959 fec_enet_open(struct net_device *dev)
1960 {
1961         struct fec_enet_private *fep = netdev_priv(dev);
1962
1963         /* I should reset the ring buffers here, but I don't yet know
1964          * a simple way to do that.
1965          */
1966         fec_set_mac_address(dev);
1967
1968         fep->sequence_done = 0;
1969         fep->link = 0;
1970
1971         if (fep->phy) {
1972                 mii_do_cmd(dev, fep->phy->ack_int);
1973                 mii_do_cmd(dev, fep->phy->config);
1974                 mii_do_cmd(dev, phy_cmd_config);  /* display configuration */
1975
1976                 /* Poll until the PHY tells us its configuration
1977                  * (not link state).
1978                  * Request is initiated by mii_do_cmd above, but answer
1979                  * comes by interrupt.
1980                  * This should take about 25 usec per register at 2.5 MHz,
1981                  * and we read approximately 5 registers.
1982                  */
1983                 while(!fep->sequence_done)
1984                         schedule();
1985
1986                 mii_do_cmd(dev, fep->phy->startup);
1987
1988                 /* Set the initial link state to true. A lot of hardware
1989                  * based on this device does not implement a PHY interrupt,
1990                  * so we are never notified of link change.
1991                  */
1992                 fep->link = 1;
1993         } else {
1994                 fep->link = 1; /* lets just try it and see */
1995                 /* no phy,  go full duplex,  it's most likely a hub chip */
1996                 fec_restart(dev, 1);
1997         }
1998
1999         netif_start_queue(dev);
2000         fep->opened = 1;
2001         return 0;               /* Success */
2002 }
2003
2004 static int
2005 fec_enet_close(struct net_device *dev)
2006 {
2007         struct fec_enet_private *fep = netdev_priv(dev);
2008
2009         /* Don't know what to do yet.
2010         */
2011         fep->opened = 0;
2012         netif_stop_queue(dev);
2013         fec_stop(dev);
2014
2015         return 0;
2016 }
2017
2018 /* Set or clear the multicast filter for this adaptor.
2019  * Skeleton taken from sunlance driver.
2020  * The CPM Ethernet implementation allows Multicast as well as individual
2021  * MAC address filtering.  Some of the drivers check to make sure it is
2022  * a group multicast address, and discard those that are not.  I guess I
2023  * will do the same for now, but just remove the test if you want
2024  * individual filtering as well (do the upper net layers want or support
2025  * this kind of feature?).
2026  */
2027
2028 #define HASH_BITS       6               /* #bits in hash */
2029 #define CRC32_POLY      0xEDB88320
2030
2031 static void set_multicast_list(struct net_device *dev)
2032 {
2033         struct fec_enet_private *fep;
2034         volatile fec_t *ep;
2035         struct dev_mc_list *dmi;
2036         unsigned int i, j, bit, data, crc;
2037         unsigned char hash;
2038
2039         fep = netdev_priv(dev);
2040         ep = fep->hwp;
2041
2042         if (dev->flags&IFF_PROMISC) {
2043                 ep->fec_r_cntrl |= 0x0008;
2044         } else {
2045
2046                 ep->fec_r_cntrl &= ~0x0008;
2047
2048                 if (dev->flags & IFF_ALLMULTI) {
2049                         /* Catch all multicast addresses, so set the
2050                          * filter to all 1's.
2051                          */
2052                         ep->fec_grp_hash_table_high = 0xffffffff;
2053                         ep->fec_grp_hash_table_low = 0xffffffff;
2054                 } else {
2055                         /* Clear filter and add the addresses in hash register.
2056                         */
2057                         ep->fec_grp_hash_table_high = 0;
2058                         ep->fec_grp_hash_table_low = 0;
2059
2060                         dmi = dev->mc_list;
2061
2062                         for (j = 0; j < dev->mc_count; j++, dmi = dmi->next)
2063                         {
2064                                 /* Only support group multicast for now.
2065                                 */
2066                                 if (!(dmi->dmi_addr[0] & 1))
2067                                         continue;
2068
2069                                 /* calculate crc32 value of mac address
2070                                 */
2071                                 crc = 0xffffffff;
2072
2073                                 for (i = 0; i < dmi->dmi_addrlen; i++)
2074                                 {
2075                                         data = dmi->dmi_addr[i];
2076                                         for (bit = 0; bit < 8; bit++, data >>= 1)
2077                                         {
2078                                                 crc = (crc >> 1) ^
2079                                                 (((crc ^ data) & 1) ? CRC32_POLY : 0);
2080                                         }
2081                                 }
2082
2083                                 /* only upper 6 bits (HASH_BITS) are used
2084                                    which point to specific bit in he hash registers
2085                                 */
2086                                 hash = (crc >> (32 - HASH_BITS)) & 0x3f;
2087
2088                                 if (hash > 31)
2089                                         ep->fec_grp_hash_table_high |= 1 << (hash - 32);
2090                                 else
2091                                         ep->fec_grp_hash_table_low |= 1 << hash;
2092                         }
2093                 }
2094         }
2095 }
2096
2097 /* Set a MAC change in hardware.
2098  */
2099 static void
2100 fec_set_mac_address(struct net_device *dev)
2101 {
2102         volatile fec_t *fecp;
2103
2104         fecp = ((struct fec_enet_private *)netdev_priv(dev))->hwp;
2105
2106         /* Set station address. */
2107         fecp->fec_addr_low = dev->dev_addr[3] | (dev->dev_addr[2] << 8) |
2108                 (dev->dev_addr[1] << 16) | (dev->dev_addr[0] << 24);
2109         fecp->fec_addr_high = (dev->dev_addr[5] << 16) |
2110                 (dev->dev_addr[4] << 24);
2111
2112 }
2113
2114  /*
2115   * XXX:  We need to clean up on failure exits here.
2116   *
2117   * index is only used in legacy code
2118   */
2119 int __init fec_enet_init(struct net_device *dev, int index)
2120 {
2121         struct fec_enet_private *fep = netdev_priv(dev);
2122         unsigned long   mem_addr;
2123         volatile cbd_t  *bdp;
2124         cbd_t           *cbd_base;
2125         volatile fec_t  *fecp;
2126         int             i, j;
2127
2128         /* Allocate memory for buffer descriptors.
2129         */
2130         mem_addr = (unsigned long)dma_alloc_coherent(NULL, PAGE_SIZE,
2131                         &fep->bd_dma, GFP_KERNEL);
2132         if (mem_addr == 0) {
2133                 printk("FEC: allocate descriptor memory failed?\n");
2134                 return -ENOMEM;
2135         }
2136
2137         spin_lock_init(&fep->hw_lock);
2138         spin_lock_init(&fep->mii_lock);
2139
2140         /* Create an Ethernet device instance.
2141         */
2142         fecp = (volatile fec_t *)dev->base_addr;
2143
2144         fep->index = index;
2145         fep->hwp = fecp;
2146         fep->netdev = dev;
2147
2148         /* Whack a reset.  We should wait for this.
2149         */
2150         fecp->fec_ecntrl = 1;
2151         udelay(10);
2152
2153         /* Set the Ethernet address */
2154 #ifdef FEC_LEGACY
2155         fec_get_mac(dev);
2156 #else
2157         {
2158                 unsigned long l;
2159                 l = fecp->fec_addr_low;
2160                 dev->dev_addr[0] = (unsigned char)((l & 0xFF000000) >> 24);
2161                 dev->dev_addr[1] = (unsigned char)((l & 0x00FF0000) >> 16);
2162                 dev->dev_addr[2] = (unsigned char)((l & 0x0000FF00) >> 8);
2163                 dev->dev_addr[3] = (unsigned char)((l & 0x000000FF) >> 0);
2164                 l = fecp->fec_addr_high;
2165                 dev->dev_addr[4] = (unsigned char)((l & 0xFF000000) >> 24);
2166                 dev->dev_addr[5] = (unsigned char)((l & 0x00FF0000) >> 16);
2167         }
2168 #endif
2169
2170         cbd_base = (cbd_t *)mem_addr;
2171
2172         /* Set receive and transmit descriptor base.
2173         */
2174         fep->rx_bd_base = cbd_base;
2175         fep->tx_bd_base = cbd_base + RX_RING_SIZE;
2176
2177         fep->dirty_tx = fep->cur_tx = fep->tx_bd_base;
2178         fep->cur_rx = fep->rx_bd_base;
2179
2180         fep->skb_cur = fep->skb_dirty = 0;
2181
2182         /* Initialize the receive buffer descriptors.
2183         */
2184         bdp = fep->rx_bd_base;
2185         for (i=0; i<FEC_ENET_RX_PAGES; i++) {
2186
2187                 /* Allocate a page.
2188                 */
2189                 mem_addr = __get_free_page(GFP_KERNEL);
2190                 /* XXX: missing check for allocation failure */
2191
2192                 /* Initialize the BD for every fragment in the page.
2193                 */
2194                 for (j=0; j<FEC_ENET_RX_FRPPG; j++) {
2195                         bdp->cbd_sc = BD_ENET_RX_EMPTY;
2196                         bdp->cbd_bufaddr = __pa(mem_addr);
2197                         mem_addr += FEC_ENET_RX_FRSIZE;
2198                         bdp++;
2199                 }
2200         }
2201
2202         /* Set the last buffer to wrap.
2203         */
2204         bdp--;
2205         bdp->cbd_sc |= BD_SC_WRAP;
2206
2207         /* ...and the same for transmmit.
2208         */
2209         bdp = fep->tx_bd_base;
2210         for (i=0, j=FEC_ENET_TX_FRPPG; i<TX_RING_SIZE; i++) {
2211                 if (j >= FEC_ENET_TX_FRPPG) {
2212                         mem_addr = __get_free_page(GFP_KERNEL);
2213                         j = 1;
2214                 } else {
2215                         mem_addr += FEC_ENET_TX_FRSIZE;
2216                         j++;
2217                 }
2218                 fep->tx_bounce[i] = (unsigned char *) mem_addr;
2219
2220                 /* Initialize the BD for every fragment in the page.
2221                 */
2222                 bdp->cbd_sc = 0;
2223                 bdp->cbd_bufaddr = 0;
2224                 bdp++;
2225         }
2226
2227         /* Set the last buffer to wrap.
2228         */
2229         bdp--;
2230         bdp->cbd_sc |= BD_SC_WRAP;
2231
2232         /* Set receive and transmit descriptor base.
2233         */
2234         fecp->fec_r_des_start = fep->bd_dma;
2235         fecp->fec_x_des_start = (unsigned long)fep->bd_dma + sizeof(cbd_t)
2236                                 * RX_RING_SIZE;
2237
2238 #ifdef FEC_LEGACY
2239         /* Install our interrupt handlers. This varies depending on
2240          * the architecture.
2241         */
2242         fec_request_intrs(dev);
2243 #endif
2244
2245         fecp->fec_grp_hash_table_high = 0;
2246         fecp->fec_grp_hash_table_low = 0;
2247         fecp->fec_r_buff_size = PKT_MAXBLR_SIZE;
2248         fecp->fec_ecntrl = 2;
2249         fecp->fec_r_des_active = 0;
2250 #ifndef CONFIG_M5272
2251         fecp->fec_hash_table_high = 0;
2252         fecp->fec_hash_table_low = 0;
2253 #endif
2254
2255         /* The FEC Ethernet specific entries in the device structure. */
2256         dev->open = fec_enet_open;
2257         dev->hard_start_xmit = fec_enet_start_xmit;
2258         dev->tx_timeout = fec_timeout;
2259         dev->watchdog_timeo = TX_TIMEOUT;
2260         dev->stop = fec_enet_close;
2261         dev->set_multicast_list = set_multicast_list;
2262
2263         for (i=0; i<NMII-1; i++)
2264                 mii_cmds[i].mii_next = &mii_cmds[i+1];
2265         mii_free = mii_cmds;
2266
2267         /* setup MII interface */
2268 #ifdef FEC_LEGACY
2269         fec_set_mii(dev, fep);
2270 #else
2271         fecp->fec_r_cntrl = OPT_FRAME_SIZE | 0x04;
2272         fecp->fec_x_cntrl = 0x00;
2273
2274         /*
2275          * Set MII speed to 2.5 MHz
2276          */
2277         fep->phy_speed = ((((clk_get_rate(fep->clk) / 2 + 4999999)
2278                                         / 2500000) / 2) & 0x3F) << 1;
2279         fecp->fec_mii_speed = fep->phy_speed;
2280         fec_restart(dev, 0);
2281 #endif
2282
2283         /* Clear and enable interrupts */
2284         fecp->fec_ievent = 0xffc00000;
2285         fecp->fec_imask = (FEC_ENET_TXF | FEC_ENET_RXF | FEC_ENET_MII);
2286
2287         /* Queue up command to detect the PHY and initialize the
2288          * remainder of the interface.
2289          */
2290         fep->phy_id_done = 0;
2291         fep->phy_addr = 0;
2292         mii_queue(dev, mk_mii_read(MII_REG_PHYIR1), mii_discover_phy);
2293
2294         return 0;
2295 }
2296
2297 /* This function is called to start or restart the FEC during a link
2298  * change.  This only happens when switching between half and full
2299  * duplex.
2300  */
2301 static void
2302 fec_restart(struct net_device *dev, int duplex)
2303 {
2304         struct fec_enet_private *fep;
2305         volatile cbd_t *bdp;
2306         volatile fec_t *fecp;
2307         int i;
2308
2309         fep = netdev_priv(dev);
2310         fecp = fep->hwp;
2311
2312         /* Whack a reset.  We should wait for this.
2313         */
2314         fecp->fec_ecntrl = 1;
2315         udelay(10);
2316
2317         /* Clear any outstanding interrupt.
2318         */
2319         fecp->fec_ievent = 0xffc00000;
2320
2321         /* Set station address.
2322         */
2323         fec_set_mac_address(dev);
2324
2325         /* Reset all multicast.
2326         */
2327         fecp->fec_grp_hash_table_high = 0;
2328         fecp->fec_grp_hash_table_low = 0;
2329
2330         /* Set maximum receive buffer size.
2331         */
2332         fecp->fec_r_buff_size = PKT_MAXBLR_SIZE;
2333
2334         /* Set receive and transmit descriptor base.
2335         */
2336         fecp->fec_r_des_start = fep->bd_dma;
2337         fecp->fec_x_des_start = (unsigned long)fep->bd_dma + sizeof(cbd_t)
2338                                 * RX_RING_SIZE;
2339
2340         fep->dirty_tx = fep->cur_tx = fep->tx_bd_base;
2341         fep->cur_rx = fep->rx_bd_base;
2342
2343         /* Reset SKB transmit buffers.
2344         */
2345         fep->skb_cur = fep->skb_dirty = 0;
2346         for (i=0; i<=TX_RING_MOD_MASK; i++) {
2347                 if (fep->tx_skbuff[i] != NULL) {
2348                         dev_kfree_skb_any(fep->tx_skbuff[i]);
2349                         fep->tx_skbuff[i] = NULL;
2350                 }
2351         }
2352
2353         /* Initialize the receive buffer descriptors.
2354         */
2355         bdp = fep->rx_bd_base;
2356         for (i=0; i<RX_RING_SIZE; i++) {
2357
2358                 /* Initialize the BD for every fragment in the page.
2359                 */
2360                 bdp->cbd_sc = BD_ENET_RX_EMPTY;
2361                 bdp++;
2362         }
2363
2364         /* Set the last buffer to wrap.
2365         */
2366         bdp--;
2367         bdp->cbd_sc |= BD_SC_WRAP;
2368
2369         /* ...and the same for transmmit.
2370         */
2371         bdp = fep->tx_bd_base;
2372         for (i=0; i<TX_RING_SIZE; i++) {
2373
2374                 /* Initialize the BD for every fragment in the page.
2375                 */
2376                 bdp->cbd_sc = 0;
2377                 bdp->cbd_bufaddr = 0;
2378                 bdp++;
2379         }
2380
2381         /* Set the last buffer to wrap.
2382         */
2383         bdp--;
2384         bdp->cbd_sc |= BD_SC_WRAP;
2385
2386         /* Enable MII mode.
2387         */
2388         if (duplex) {
2389                 fecp->fec_r_cntrl = OPT_FRAME_SIZE | 0x04;/* MII enable */
2390                 fecp->fec_x_cntrl = 0x04;                 /* FD enable */
2391         } else {
2392                 /* MII enable|No Rcv on Xmit */
2393                 fecp->fec_r_cntrl = OPT_FRAME_SIZE | 0x06;
2394                 fecp->fec_x_cntrl = 0x00;
2395         }
2396         fep->full_duplex = duplex;
2397
2398         /* Set MII speed.
2399         */
2400         fecp->fec_mii_speed = fep->phy_speed;
2401
2402         /* And last, enable the transmit and receive processing.
2403         */
2404         fecp->fec_ecntrl = 2;
2405         fecp->fec_r_des_active = 0;
2406
2407         /* Enable interrupts we wish to service.
2408         */
2409         fecp->fec_imask = (FEC_ENET_TXF | FEC_ENET_RXF | FEC_ENET_MII);
2410 }
2411
2412 static void
2413 fec_stop(struct net_device *dev)
2414 {
2415         volatile fec_t *fecp;
2416         struct fec_enet_private *fep;
2417
2418         fep = netdev_priv(dev);
2419         fecp = fep->hwp;
2420
2421         /*
2422         ** We cannot expect a graceful transmit stop without link !!!
2423         */
2424         if (fep->link)
2425                 {
2426                 fecp->fec_x_cntrl = 0x01;       /* Graceful transmit stop */
2427                 udelay(10);
2428                 if (!(fecp->fec_ievent & FEC_ENET_GRA))
2429                         printk("fec_stop : Graceful transmit stop did not complete !\n");
2430                 }
2431
2432         /* Whack a reset.  We should wait for this.
2433         */
2434         fecp->fec_ecntrl = 1;
2435         udelay(10);
2436
2437         /* Clear outstanding MII command interrupts.
2438         */
2439         fecp->fec_ievent = FEC_ENET_MII;
2440
2441         fecp->fec_imask = FEC_ENET_MII;
2442         fecp->fec_mii_speed = fep->phy_speed;
2443 }
2444
2445 #ifdef FEC_LEGACY
2446 static int __init fec_enet_module_init(void)
2447 {
2448         struct net_device *dev;
2449         int i, err;
2450
2451         printk("FEC ENET Version 0.2\n");
2452
2453         for (i = 0; (i < FEC_MAX_PORTS); i++) {
2454                 dev = alloc_etherdev(sizeof(struct fec_enet_private));
2455                 if (!dev)
2456                         return -ENOMEM;
2457                 dev->base_addr = (unsigned long)fec_hw[i];
2458                 err = fec_enet_init(dev, i);
2459                 if (err) {
2460                         free_netdev(dev);
2461                         continue;
2462                 }
2463                 if (register_netdev(dev) != 0) {
2464                         /* XXX: missing cleanup here */
2465                         free_netdev(dev);
2466                         return -EIO;
2467                 }
2468
2469                 printk("%s: ethernet %pM\n", dev->name, dev->dev_addr);
2470         }
2471         return 0;
2472 }
2473 #else
2474
2475 static int __devinit
2476 fec_probe(struct platform_device *pdev)
2477 {
2478         struct fec_enet_private *fep;
2479         struct net_device *ndev;
2480         int i, irq, ret = 0;
2481         struct resource *r;
2482
2483         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2484         if (!r)
2485                 return -ENXIO;
2486
2487         r = request_mem_region(r->start, resource_size(r), pdev->name);
2488         if (!r)
2489                 return -EBUSY;
2490
2491         /* Init network device */
2492         ndev = alloc_etherdev(sizeof(struct fec_enet_private));
2493         if (!ndev)
2494                 return -ENOMEM;
2495
2496         SET_NETDEV_DEV(ndev, &pdev->dev);
2497
2498         /* setup board info structure */
2499         fep = netdev_priv(ndev);
2500         memset(fep, 0, sizeof(*fep));
2501
2502         ndev->base_addr = (unsigned long)ioremap(r->start, resource_size(r));
2503
2504         if (!ndev->base_addr) {
2505                 ret = -ENOMEM;
2506                 goto failed_ioremap;
2507         }
2508
2509         platform_set_drvdata(pdev, ndev);
2510
2511         /* This device has up to three irqs on some platforms */
2512         for (i = 0; i < 3; i++) {
2513                 irq = platform_get_irq(pdev, i);
2514                 if (i && irq < 0)
2515                         break;
2516                 ret = request_irq(irq, fec_enet_interrupt, IRQF_DISABLED, pdev->name, ndev);
2517                 if (ret) {
2518                         while (i >= 0) {
2519                                 irq = platform_get_irq(pdev, i);
2520                                 free_irq(irq, ndev);
2521                                 i--;
2522                         }
2523                         goto failed_irq;
2524                 }
2525         }
2526
2527         fep->clk = clk_get(&pdev->dev, "fec_clk");
2528         if (IS_ERR(fep->clk)) {
2529                 ret = PTR_ERR(fep->clk);
2530                 goto failed_clk;
2531         }
2532         clk_enable(fep->clk);
2533
2534         ret = fec_enet_init(ndev, 0);
2535         if (ret)
2536                 goto failed_init;
2537
2538         ret = register_netdev(ndev);
2539         if (ret)
2540                 goto failed_register;
2541
2542         return 0;
2543
2544 failed_register:
2545 failed_init:
2546         clk_disable(fep->clk);
2547         clk_put(fep->clk);
2548 failed_clk:
2549         for (i = 0; i < 3; i++) {
2550                 irq = platform_get_irq(pdev, i);
2551                 if (irq > 0)
2552                         free_irq(irq, ndev);
2553         }
2554 failed_irq:
2555         iounmap((void __iomem *)ndev->base_addr);
2556 failed_ioremap:
2557         free_netdev(ndev);
2558
2559         return ret;
2560 }
2561
2562 static int __devexit
2563 fec_drv_remove(struct platform_device *pdev)
2564 {
2565         struct net_device *ndev = platform_get_drvdata(pdev);
2566         struct fec_enet_private *fep = netdev_priv(ndev);
2567
2568         platform_set_drvdata(pdev, NULL);
2569
2570         fec_stop(ndev);
2571         clk_disable(fep->clk);
2572         clk_put(fep->clk);
2573         iounmap((void __iomem *)ndev->base_addr);
2574         unregister_netdev(ndev);
2575         free_netdev(ndev);
2576         return 0;
2577 }
2578
2579 static int
2580 fec_suspend(struct platform_device *dev, pm_message_t state)
2581 {
2582         struct net_device *ndev = platform_get_drvdata(dev);
2583         struct fec_enet_private *fep;
2584
2585         if (ndev) {
2586                 fep = netdev_priv(ndev);
2587                 if (netif_running(ndev)) {
2588                         netif_device_detach(ndev);
2589                         fec_stop(ndev);
2590                 }
2591         }
2592         return 0;
2593 }
2594
2595 static int
2596 fec_resume(struct platform_device *dev)
2597 {
2598         struct net_device *ndev = platform_get_drvdata(dev);
2599
2600         if (ndev) {
2601                 if (netif_running(ndev)) {
2602                         fec_enet_init(ndev, 0);
2603                         netif_device_attach(ndev);
2604                 }
2605         }
2606         return 0;
2607 }
2608
2609 static struct platform_driver fec_driver = {
2610         .driver = {
2611                 .name    = "fec",
2612                 .owner   = THIS_MODULE,
2613         },
2614         .probe   = fec_probe,
2615         .remove  = __devexit_p(fec_drv_remove),
2616         .suspend = fec_suspend,
2617         .resume  = fec_resume,
2618 };
2619
2620 static int __init
2621 fec_enet_module_init(void)
2622 {
2623         printk(KERN_INFO "FEC Ethernet Driver\n");
2624
2625         return platform_driver_register(&fec_driver);
2626 }
2627
2628 static void __exit
2629 fec_enet_cleanup(void)
2630 {
2631         platform_driver_unregister(&fec_driver);
2632 }
2633
2634 module_exit(fec_enet_cleanup);
2635
2636 #endif /* FEC_LEGACY */
2637
2638 module_init(fec_enet_module_init);
2639
2640 MODULE_LICENSE("GPL");