fec.c 55.4 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
/*
 * Fast Ethernet Controller (FEC) driver for Motorola MPC8xx.
 * Copyright (c) 1997 Dan Malek (dmalek@jlc.net)
 *
5
 * Right now, I am very wasteful with the buffers.  I allocate memory
Linus Torvalds's avatar
Linus Torvalds committed
6
7
8
9
10
11
12
13
14
 * pages and then divide them into 2K frame buffers.  This way I know I
 * have buffers large enough to hold one frame within one buffer descriptor.
 * Once I get this working, I will use 64 or 128 byte CPM buffers, which
 * will be much more memory efficient and will easily handle lots of
 * small packets.
 *
 * Much better multiple PHY support by Magnus Damm.
 * Copyright (c) 2000 Ericsson Radio Systems AB.
 *
15
16
 * Support for FEC controller of ColdFire processors.
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/ptrace.h>
#include <linux/errno.h>
#include <linux/ioport.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/spinlock.h>
#include <linux/workqueue.h>
#include <linux/bitops.h>
39
40
#include <linux/io.h>
#include <linux/irq.h>
41
#include <linux/clk.h>
42
#include <linux/platform_device.h>
Linus Torvalds's avatar
Linus Torvalds committed
43

44
#include <asm/cacheflush.h>
45
46

#ifndef CONFIG_ARCH_MXC
Linus Torvalds's avatar
Linus Torvalds committed
47
48
#include <asm/coldfire.h>
#include <asm/mcfsim.h>
49
#endif
50

Linus Torvalds's avatar
Linus Torvalds committed
51
52
#include "fec.h"

53
54
55
56
57
58
59
#ifdef CONFIG_ARCH_MXC
#include <mach/hardware.h>
#define FEC_ALIGNMENT	0xf
#else
#define FEC_ALIGNMENT	0x3
#endif

60
61
62
/*
 * Define the fixed address of the FEC hardware.
 */
63
#if defined(CONFIG_M5272)
64
#define HAVE_mii_link_interrupt
Linus Torvalds's avatar
Linus Torvalds committed
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

static unsigned char	fec_mac_default[] = {
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};

/*
 * Some hardware gets it MAC address out of local flash memory.
 * if this is non-zero then assume it is the address to get MAC from.
 */
#if defined(CONFIG_NETtel)
#define	FEC_FLASHMAC	0xf0006006
#elif defined(CONFIG_GILBARCONAP) || defined(CONFIG_SCALES)
#define	FEC_FLASHMAC	0xf0006000
#elif defined(CONFIG_CANCam)
#define	FEC_FLASHMAC	0xf0020000
80
81
82
83
#elif defined (CONFIG_M5272C3)
#define	FEC_FLASHMAC	(0xffe04000 + 4)
#elif defined(CONFIG_MOD5272)
#define FEC_FLASHMAC 	0xffc0406b
Linus Torvalds's avatar
Linus Torvalds committed
84
85
86
#else
#define	FEC_FLASHMAC	0
#endif
87
#endif /* CONFIG_M5272 */
88

Linus Torvalds's avatar
Linus Torvalds committed
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
/* Forward declarations of some structures to support different PHYs
*/

typedef struct {
	uint mii_data;
	void (*funct)(uint mii_reg, struct net_device *dev);
} phy_cmd_t;

typedef struct {
	uint id;
	char *name;

	const phy_cmd_t *config;
	const phy_cmd_t *startup;
	const phy_cmd_t *ack_int;
	const phy_cmd_t *shutdown;
} phy_info_t;

/* The number of Tx and Rx buffers.  These are allocated from the page
 * pool.  The code may assume these are power of two, so it it best
 * to keep them that size.
 * We don't need to allocate pages for the transmitter.  We just use
 * the skbuffer directly.
 */
#define FEC_ENET_RX_PAGES	8
#define FEC_ENET_RX_FRSIZE	2048
#define FEC_ENET_RX_FRPPG	(PAGE_SIZE / FEC_ENET_RX_FRSIZE)
#define RX_RING_SIZE		(FEC_ENET_RX_FRPPG * FEC_ENET_RX_PAGES)
#define FEC_ENET_TX_FRSIZE	2048
#define FEC_ENET_TX_FRPPG	(PAGE_SIZE / FEC_ENET_TX_FRSIZE)
#define TX_RING_SIZE		16	/* Must be power of two */
#define TX_RING_MOD_MASK	15	/*   for this to work */

122
#if (((RX_RING_SIZE + TX_RING_SIZE) * 8) > PAGE_SIZE)
123
#error "FEC: descriptor ring size constants too large"
124
125
#endif

Linus Torvalds's avatar
Linus Torvalds committed
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
/* Interrupt events/masks.
*/
#define FEC_ENET_HBERR	((uint)0x80000000)	/* Heartbeat error */
#define FEC_ENET_BABR	((uint)0x40000000)	/* Babbling receiver */
#define FEC_ENET_BABT	((uint)0x20000000)	/* Babbling transmitter */
#define FEC_ENET_GRA	((uint)0x10000000)	/* Graceful stop complete */
#define FEC_ENET_TXF	((uint)0x08000000)	/* Full frame transmitted */
#define FEC_ENET_TXB	((uint)0x04000000)	/* A buffer was transmitted */
#define FEC_ENET_RXF	((uint)0x02000000)	/* Full frame received */
#define FEC_ENET_RXB	((uint)0x01000000)	/* A buffer was received */
#define FEC_ENET_MII	((uint)0x00800000)	/* MII interrupt */
#define FEC_ENET_EBERR	((uint)0x00400000)	/* SDMA bus error */

/* The FEC stores dest/src/type, data, and checksum for receive packets.
 */
#define PKT_MAXBUF_SIZE		1518
#define PKT_MINBUF_SIZE		64
#define PKT_MAXBLR_SIZE		1520


/*
147
 * The 5270/5271/5280/5282/532x RX control register also contains maximum frame
Linus Torvalds's avatar
Linus Torvalds committed
148
149
150
 * size bits. Other FEC hardware does not, so we need to take that into
 * account when setting it.
 */
151
#if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
152
    defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARCH_MXC)
Linus Torvalds's avatar
Linus Torvalds committed
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
#define	OPT_FRAME_SIZE	(PKT_MAXBUF_SIZE << 16)
#else
#define	OPT_FRAME_SIZE	0
#endif

/* The FEC buffer descriptors track the ring buffers.  The rx_bd_base and
 * tx_bd_base always point to the base of the buffer descriptors.  The
 * cur_rx and cur_tx point to the currently available buffer.
 * The dirty_tx tracks the current buffer that is being sent by the
 * controller.  The cur_tx and dirty_tx are equal under both completely
 * empty and completely full conditions.  The empty/ready indicator in
 * the buffer descriptor determines the actual condition.
 */
struct fec_enet_private {
	/* Hardware registers of the FEC device */
Sascha Hauer's avatar
Sascha Hauer committed
168
	void __iomem *hwp;
Linus Torvalds's avatar
Linus Torvalds committed
169

Greg Ungerer's avatar
Greg Ungerer committed
170
171
	struct net_device *netdev;

172
173
	struct clk *clk;

Linus Torvalds's avatar
Linus Torvalds committed
174
175
176
177
178
179
180
181
	/* The saved address of a sent-in-place packet/buffer, for skfree(). */
	unsigned char *tx_bounce[TX_RING_SIZE];
	struct	sk_buff* tx_skbuff[TX_RING_SIZE];
	ushort	skb_cur;
	ushort	skb_dirty;

	/* CPM dual port RAM relative addresses.
	*/
182
	dma_addr_t	bd_dma;
183
184
185
186
187
188
189
190
	/* Address of Rx and Tx buffers. */
	struct bufdesc	*rx_bd_base;
	struct bufdesc	*tx_bd_base;
	/* The next free ring entry */
	struct bufdesc	*cur_rx, *cur_tx; 
	/* The ring entries to be free()ed. */
	struct bufdesc	*dirty_tx;

Linus Torvalds's avatar
Linus Torvalds committed
191
	uint	tx_full;
192
193
194
195
	/* hold while accessing the HW like ringbuffer for tx/rx but not MAC */
	spinlock_t hw_lock;
	/* hold while accessing the mii_list_t() elements */
	spinlock_t mii_lock;
Linus Torvalds's avatar
Linus Torvalds committed
196
197
198
199
200

	uint	phy_id;
	uint	phy_id_done;
	uint	phy_status;
	uint	phy_speed;
201
	phy_info_t const	*phy;
Linus Torvalds's avatar
Linus Torvalds committed
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
	struct work_struct phy_task;

	uint	sequence_done;
	uint	mii_phy_task_queued;

	uint	phy_addr;

	int	index;
	int	opened;
	int	link;
	int	old_link;
	int	full_duplex;
};

static int fec_enet_open(struct net_device *dev);
static int fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev);
static void fec_enet_mii(struct net_device *dev);
219
static irqreturn_t fec_enet_interrupt(int irq, void * dev_id);
Linus Torvalds's avatar
Linus Torvalds committed
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
static void fec_enet_tx(struct net_device *dev);
static void fec_enet_rx(struct net_device *dev);
static int fec_enet_close(struct net_device *dev);
static void set_multicast_list(struct net_device *dev);
static void fec_restart(struct net_device *dev, int duplex);
static void fec_stop(struct net_device *dev);
static void fec_set_mac_address(struct net_device *dev);


/* MII processing.  We keep this as simple as possible.  Requests are
 * placed on the list (if there is room).  When the request is finished
 * by the MII, an optional function may be called.
 */
typedef struct mii_list {
	uint	mii_regval;
	void	(*mii_func)(uint val, struct net_device *dev);
	struct	mii_list *mii_next;
} mii_list_t;

#define		NMII	20
240
241
242
243
static mii_list_t	mii_cmds[NMII];
static mii_list_t	*mii_free;
static mii_list_t	*mii_head;
static mii_list_t	*mii_tail;
Linus Torvalds's avatar
Linus Torvalds committed
244

245
static int	mii_queue(struct net_device *dev, int request,
Linus Torvalds's avatar
Linus Torvalds committed
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
				void (*func)(uint, struct net_device *));

/* Make MII read/write commands for the FEC.
*/
#define mk_mii_read(REG)	(0x60020000 | ((REG & 0x1f) << 18))
#define mk_mii_write(REG, VAL)	(0x50020000 | ((REG & 0x1f) << 18) | \
						(VAL & 0xffff))
#define mk_mii_end	0

/* Transmitter timeout.
*/
#define TX_TIMEOUT (2*HZ)

/* Register definitions for the PHY.
*/

#define MII_REG_CR          0  /* Control Register                         */
#define MII_REG_SR          1  /* Status Register                          */
#define MII_REG_PHYIR1      2  /* PHY Identification Register 1            */
#define MII_REG_PHYIR2      3  /* PHY Identification Register 2            */
266
#define MII_REG_ANAR        4  /* A-N Advertisement Register               */
Linus Torvalds's avatar
Linus Torvalds committed
267
268
269
270
271
272
273
274
275
276
277
#define MII_REG_ANLPAR      5  /* A-N Link Partner Ability Register        */
#define MII_REG_ANER        6  /* A-N Expansion Register                   */
#define MII_REG_ANNPTR      7  /* A-N Next Page Transmit Register          */
#define MII_REG_ANLPRNPR    8  /* A-N Link Partner Received Next Page Reg. */

/* values for phy_status */

#define PHY_CONF_ANE	0x0001  /* 1 auto-negotiation enabled */
#define PHY_CONF_LOOP	0x0002  /* 1 loopback mode enabled */
#define PHY_CONF_SPMASK	0x00f0  /* mask for speed */
#define PHY_CONF_10HDX	0x0010  /* 10 Mbit half duplex supported */
278
#define PHY_CONF_10FDX	0x0020  /* 10 Mbit full duplex supported */
Linus Torvalds's avatar
Linus Torvalds committed
279
#define PHY_CONF_100HDX	0x0040  /* 100 Mbit half duplex supported */
280
#define PHY_CONF_100FDX	0x0080  /* 100 Mbit full duplex supported */
Linus Torvalds's avatar
Linus Torvalds committed
281
282
283
284
285
286

#define PHY_STAT_LINK	0x0100  /* 1 up - 0 down */
#define PHY_STAT_FAULT	0x0200  /* 1 remote fault */
#define PHY_STAT_ANC	0x0400  /* 1 auto-negotiation complete	*/
#define PHY_STAT_SPMASK	0xf000  /* mask for speed */
#define PHY_STAT_10HDX	0x1000  /* 10 Mbit half duplex selected	*/
287
#define PHY_STAT_10FDX	0x2000  /* 10 Mbit full duplex selected	*/
Linus Torvalds's avatar
Linus Torvalds committed
288
#define PHY_STAT_100HDX	0x4000  /* 100 Mbit half duplex selected */
289
#define PHY_STAT_100FDX	0x8000  /* 100 Mbit full duplex selected */
Linus Torvalds's avatar
Linus Torvalds committed
290
291
292
293
294


static int
fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
Sascha Hauer's avatar
Sascha Hauer committed
295
	struct fec_enet_private *fep = netdev_priv(dev);
296
	struct bufdesc *bdp;
297
	unsigned short	status;
298
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
299
300
301
302
303
304

	if (!fep->link) {
		/* Link is down or autonegotiation is in progress. */
		return 1;
	}

305
	spin_lock_irqsave(&fep->hw_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
306
307
308
	/* Fill in a Tx ring entry */
	bdp = fep->cur_tx;

309
	status = bdp->cbd_sc;
Linus Torvalds's avatar
Linus Torvalds committed
310
#ifndef final_version
311
	if (status & BD_ENET_TX_READY) {
Linus Torvalds's avatar
Linus Torvalds committed
312
313
314
315
		/* Ooops.  All transmit buffers are full.  Bail out.
		 * This should not happen, since dev->tbusy should be set.
		 */
		printk("%s: tx queue full!.\n", dev->name);
316
		spin_unlock_irqrestore(&fep->hw_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
317
318
319
320
321
322
		return 1;
	}
#endif

	/* Clear all of the status flags.
	 */
323
	status &= ~BD_ENET_TX_STATS;
Linus Torvalds's avatar
Linus Torvalds committed
324
325
326
327
328
329
330
331
332
333
334

	/* Set buffer length and buffer pointer.
	*/
	bdp->cbd_bufaddr = __pa(skb->data);
	bdp->cbd_datlen = skb->len;

	/*
	 *	On some FEC implementations data must be aligned on
	 *	4-byte boundaries. Use bounce buffers to copy data
	 *	and get it aligned. Ugh.
	 */
335
	if (bdp->cbd_bufaddr & FEC_ALIGNMENT) {
Linus Torvalds's avatar
Linus Torvalds committed
336
337
		unsigned int index;
		index = bdp - fep->tx_bd_base;
338
		memcpy(fep->tx_bounce[index], (void *)skb->data, skb->len);
Linus Torvalds's avatar
Linus Torvalds committed
339
340
341
342
343
344
345
		bdp->cbd_bufaddr = __pa(fep->tx_bounce[index]);
	}

	/* Save skb pointer.
	*/
	fep->tx_skbuff[fep->skb_cur] = skb;

346
	dev->stats.tx_bytes += skb->len;
Linus Torvalds's avatar
Linus Torvalds committed
347
	fep->skb_cur = (fep->skb_cur+1) & TX_RING_MOD_MASK;
348

Linus Torvalds's avatar
Linus Torvalds committed
349
350
351
	/* Push the data cache so the CPM does not get stale memory
	 * data.
	 */
352
353
	dma_sync_single(NULL, bdp->cbd_bufaddr,
			bdp->cbd_datlen, DMA_TO_DEVICE);
Linus Torvalds's avatar
Linus Torvalds committed
354

355
356
	/* Send it on its way.  Tell FEC it's ready, interrupt when done,
	 * it's the last BD of the frame, and to put the CRC on the end.
Linus Torvalds's avatar
Linus Torvalds committed
357
358
	 */

359
	status |= (BD_ENET_TX_READY | BD_ENET_TX_INTR
Linus Torvalds's avatar
Linus Torvalds committed
360
			| BD_ENET_TX_LAST | BD_ENET_TX_TC);
361
	bdp->cbd_sc = status;
Linus Torvalds's avatar
Linus Torvalds committed
362
363
364
365

	dev->trans_start = jiffies;

	/* Trigger transmission start */
Sascha Hauer's avatar
Sascha Hauer committed
366
	writel(0, fep->hwp + FEC_X_DES_ACTIVE);
Linus Torvalds's avatar
Linus Torvalds committed
367
368
369

	/* If this was the last BD in the ring, start at the beginning again.
	*/
370
	if (status & BD_ENET_TX_WRAP) {
Linus Torvalds's avatar
Linus Torvalds committed
371
372
373
374
375
376
377
378
379
380
		bdp = fep->tx_bd_base;
	} else {
		bdp++;
	}

	if (bdp == fep->dirty_tx) {
		fep->tx_full = 1;
		netif_stop_queue(dev);
	}

381
	fep->cur_tx = bdp;
Linus Torvalds's avatar
Linus Torvalds committed
382

383
	spin_unlock_irqrestore(&fep->hw_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
384
385
386
387
388
389
390
391
392
393

	return 0;
}

static void
fec_timeout(struct net_device *dev)
{
	struct fec_enet_private *fep = netdev_priv(dev);

	printk("%s: transmit timed out.\n", dev->name);
394
	dev->stats.tx_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
395
396
397
#ifndef final_version
	{
	int	i;
398
	struct bufdesc *bdp;
Linus Torvalds's avatar
Linus Torvalds committed
399
400
401
402
403
404
405
406
407

	printk("Ring data dump: cur_tx %lx%s, dirty_tx %lx cur_rx: %lx\n",
	       (unsigned long)fep->cur_tx, fep->tx_full ? " (full)" : "",
	       (unsigned long)fep->dirty_tx,
	       (unsigned long)fep->cur_rx);

	bdp = fep->tx_bd_base;
	printk(" tx: %u buffers\n",  TX_RING_SIZE);
	for (i = 0 ; i < TX_RING_SIZE; i++) {
408
		printk("  %08x: %04x %04x %08x\n",
Linus Torvalds's avatar
Linus Torvalds committed
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
		       (uint) bdp,
		       bdp->cbd_sc,
		       bdp->cbd_datlen,
		       (int) bdp->cbd_bufaddr);
		bdp++;
	}

	bdp = fep->rx_bd_base;
	printk(" rx: %lu buffers\n",  (unsigned long) RX_RING_SIZE);
	for (i = 0 ; i < RX_RING_SIZE; i++) {
		printk("  %08x: %04x %04x %08x\n",
		       (uint) bdp,
		       bdp->cbd_sc,
		       bdp->cbd_datlen,
		       (int) bdp->cbd_bufaddr);
		bdp++;
	}
	}
#endif
428
	fec_restart(dev, fep->full_duplex);
Linus Torvalds's avatar
Linus Torvalds committed
429
430
431
432
433
434
435
	netif_wake_queue(dev);
}

/* The interrupt handler.
 * This is called from the MPC core interrupt.
 */
static irqreturn_t
436
fec_enet_interrupt(int irq, void * dev_id)
Linus Torvalds's avatar
Linus Torvalds committed
437
438
{
	struct	net_device *dev = dev_id;
Sascha Hauer's avatar
Sascha Hauer committed
439
	struct fec_enet_private *fep = netdev_priv(dev);
Linus Torvalds's avatar
Linus Torvalds committed
440
	uint	int_events;
441
	irqreturn_t ret = IRQ_NONE;
Linus Torvalds's avatar
Linus Torvalds committed
442

Sascha Hauer's avatar
Sascha Hauer committed
443
	/* Get the interrupt events that caused us to be here. */
444
	do {
Sascha Hauer's avatar
Sascha Hauer committed
445
446
		int_events = readl(fep->hwp + FEC_IEVENT);
		writel(int_events, fep->hwp + FEC_IEVENT);
Linus Torvalds's avatar
Linus Torvalds committed
447

Sascha Hauer's avatar
Sascha Hauer committed
448
		/* Handle receive event in its own function. */
Linus Torvalds's avatar
Linus Torvalds committed
449
		if (int_events & FEC_ENET_RXF) {
450
			ret = IRQ_HANDLED;
Linus Torvalds's avatar
Linus Torvalds committed
451
452
453
454
			fec_enet_rx(dev);
		}

		/* Transmit OK, or non-fatal error. Update the buffer
Sascha Hauer's avatar
Sascha Hauer committed
455
456
457
		 * descriptors. FEC handles all errors, we just discover
		 * them as part of the transmit process.
		 */
Linus Torvalds's avatar
Linus Torvalds committed
458
		if (int_events & FEC_ENET_TXF) {
459
			ret = IRQ_HANDLED;
Linus Torvalds's avatar
Linus Torvalds committed
460
461
462
463
			fec_enet_tx(dev);
		}

		if (int_events & FEC_ENET_MII) {
464
			ret = IRQ_HANDLED;
Linus Torvalds's avatar
Linus Torvalds committed
465
466
			fec_enet_mii(dev);
		}
467

468
469
470
	} while (int_events);

	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
471
472
473
474
475
476
477
}


static void
fec_enet_tx(struct net_device *dev)
{
	struct	fec_enet_private *fep;
478
	struct bufdesc *bdp;
479
	unsigned short status;
Linus Torvalds's avatar
Linus Torvalds committed
480
481
482
	struct	sk_buff	*skb;

	fep = netdev_priv(dev);
483
	spin_lock_irq(&fep->hw_lock);
Linus Torvalds's avatar
Linus Torvalds committed
484
485
	bdp = fep->dirty_tx;

486
	while (((status = bdp->cbd_sc) & BD_ENET_TX_READY) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
487
488
489
490
		if (bdp == fep->cur_tx && fep->tx_full == 0) break;

		skb = fep->tx_skbuff[fep->skb_dirty];
		/* Check for errors. */
491
		if (status & (BD_ENET_TX_HB | BD_ENET_TX_LC |
Linus Torvalds's avatar
Linus Torvalds committed
492
493
				   BD_ENET_TX_RL | BD_ENET_TX_UN |
				   BD_ENET_TX_CSL)) {
494
			dev->stats.tx_errors++;
495
			if (status & BD_ENET_TX_HB)  /* No heartbeat */
496
				dev->stats.tx_heartbeat_errors++;
497
			if (status & BD_ENET_TX_LC)  /* Late collision */
498
				dev->stats.tx_window_errors++;
499
			if (status & BD_ENET_TX_RL)  /* Retrans limit */
500
				dev->stats.tx_aborted_errors++;
501
			if (status & BD_ENET_TX_UN)  /* Underrun */
502
				dev->stats.tx_fifo_errors++;
503
			if (status & BD_ENET_TX_CSL) /* Carrier lost */
504
				dev->stats.tx_carrier_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
505
		} else {
506
			dev->stats.tx_packets++;
Linus Torvalds's avatar
Linus Torvalds committed
507
508
509
		}

#ifndef final_version
510
		if (status & BD_ENET_TX_READY)
Linus Torvalds's avatar
Linus Torvalds committed
511
512
513
514
515
			printk("HEY! Enet xmit interrupt and TX_READY.\n");
#endif
		/* Deferred means some collisions occurred during transmit,
		 * but we eventually sent the packet OK.
		 */
516
		if (status & BD_ENET_TX_DEF)
517
			dev->stats.collisions++;
518

Linus Torvalds's avatar
Linus Torvalds committed
519
520
521
522
523
		/* Free the sk buffer associated with this last transmit.
		 */
		dev_kfree_skb_any(skb);
		fep->tx_skbuff[fep->skb_dirty] = NULL;
		fep->skb_dirty = (fep->skb_dirty + 1) & TX_RING_MOD_MASK;
524

Linus Torvalds's avatar
Linus Torvalds committed
525
526
		/* Update pointer to next buffer descriptor to be transmitted.
		 */
527
		if (status & BD_ENET_TX_WRAP)
Linus Torvalds's avatar
Linus Torvalds committed
528
529
530
			bdp = fep->tx_bd_base;
		else
			bdp++;
531

Linus Torvalds's avatar
Linus Torvalds committed
532
533
534
535
536
537
538
539
540
		/* Since we have freed up a buffer, the ring is no longer
		 * full.
		 */
		if (fep->tx_full) {
			fep->tx_full = 0;
			if (netif_queue_stopped(dev))
				netif_wake_queue(dev);
		}
	}
541
	fep->dirty_tx = bdp;
542
	spin_unlock_irq(&fep->hw_lock);
Linus Torvalds's avatar
Linus Torvalds committed
543
544
545
546
547
548
549
550
551
552
553
}


/* During a receive, the cur_rx points to the current incoming buffer.
 * When we update through the ring, if the next incoming buffer has
 * not been given to the system, we just set the empty indicator,
 * effectively tossing the packet.
 */
static void
fec_enet_rx(struct net_device *dev)
{
Sascha Hauer's avatar
Sascha Hauer committed
554
	struct	fec_enet_private *fep = netdev_priv(dev);
555
	struct bufdesc *bdp;
556
	unsigned short status;
Linus Torvalds's avatar
Linus Torvalds committed
557
558
559
	struct	sk_buff	*skb;
	ushort	pkt_len;
	__u8 *data;
560

561
562
#ifdef CONFIG_M532x
	flush_cache_all();
563
#endif
Linus Torvalds's avatar
Linus Torvalds committed
564

565
566
	spin_lock_irq(&fep->hw_lock);

Linus Torvalds's avatar
Linus Torvalds committed
567
568
569
570
571
	/* First, grab all of the stats for the incoming packet.
	 * These get messed up if we get called due to a busy condition.
	 */
	bdp = fep->cur_rx;

572
while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) {
Linus Torvalds's avatar
Linus Torvalds committed
573
574
575
576
577

#ifndef final_version
	/* Since we have allocated space to hold a complete frame,
	 * the last indicator should be set.
	 */
578
	if ((status & BD_ENET_RX_LAST) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
579
580
581
582
583
584
585
		printk("FEC ENET: rcv is not +last\n");
#endif

	if (!fep->opened)
		goto rx_processing_done;

	/* Check for errors. */
586
	if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
Linus Torvalds's avatar
Linus Torvalds committed
587
			   BD_ENET_RX_CR | BD_ENET_RX_OV)) {
588
		dev->stats.rx_errors++;
589
		if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH)) {
Linus Torvalds's avatar
Linus Torvalds committed
590
		/* Frame too long or too short. */
591
			dev->stats.rx_length_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
592
		}
593
		if (status & BD_ENET_RX_NO)	/* Frame alignment */
594
			dev->stats.rx_frame_errors++;
595
		if (status & BD_ENET_RX_CR)	/* CRC Error */
596
			dev->stats.rx_crc_errors++;
597
		if (status & BD_ENET_RX_OV)	/* FIFO overrun */
598
			dev->stats.rx_fifo_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
599
600
601
602
603
604
	}

	/* Report late collisions as a frame error.
	 * On this error, the BD is closed, but we don't know what we
	 * have in the buffer.  So, just drop this frame on the floor.
	 */
605
	if (status & BD_ENET_RX_CL) {
606
607
		dev->stats.rx_errors++;
		dev->stats.rx_frame_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
608
609
610
611
612
		goto rx_processing_done;
	}

	/* Process the incoming frame.
	 */
613
	dev->stats.rx_packets++;
Linus Torvalds's avatar
Linus Torvalds committed
614
	pkt_len = bdp->cbd_datlen;
615
	dev->stats.rx_bytes += pkt_len;
Linus Torvalds's avatar
Linus Torvalds committed
616
617
	data = (__u8*)__va(bdp->cbd_bufaddr);

618
619
620
	dma_sync_single(NULL, (unsigned long)__pa(data),
			pkt_len - 4, DMA_FROM_DEVICE);

Linus Torvalds's avatar
Linus Torvalds committed
621
622
623
624
625
626
627
628
629
	/* This does 16 byte alignment, exactly what we need.
	 * The packet length includes FCS, but we don't want to
	 * include that when passing upstream as it messes up
	 * bridging applications.
	 */
	skb = dev_alloc_skb(pkt_len-4);

	if (skb == NULL) {
		printk("%s: Memory squeeze, dropping packet.\n", dev->name);
630
		dev->stats.rx_dropped++;
Linus Torvalds's avatar
Linus Torvalds committed
631
632
	} else {
		skb_put(skb,pkt_len-4);	/* Make room */
633
		skb_copy_to_linear_data(skb, data, pkt_len-4);
Linus Torvalds's avatar
Linus Torvalds committed
634
635
636
637
638
639
640
		skb->protocol=eth_type_trans(skb,dev);
		netif_rx(skb);
	}
  rx_processing_done:

	/* Clear the status flags for this buffer.
	*/
641
	status &= ~BD_ENET_RX_STATS;
Linus Torvalds's avatar
Linus Torvalds committed
642
643
644

	/* Mark the buffer empty.
	*/
645
646
	status |= BD_ENET_RX_EMPTY;
	bdp->cbd_sc = status;
Linus Torvalds's avatar
Linus Torvalds committed
647
648
649

	/* Update BD pointer to next entry.
	*/
650
	if (status & BD_ENET_RX_WRAP)
Linus Torvalds's avatar
Linus Torvalds committed
651
652
653
		bdp = fep->rx_bd_base;
	else
		bdp++;
654

Linus Torvalds's avatar
Linus Torvalds committed
655
656
657
658
659
#if 1
	/* Doing this here will keep the FEC running while we process
	 * incoming frames.  On a heavily loaded network, we should be
	 * able to keep up at the expense of system resources.
	 */
Sascha Hauer's avatar
Sascha Hauer committed
660
	writel(0, fep->hwp + FEC_R_DES_ACTIVE);
Linus Torvalds's avatar
Linus Torvalds committed
661
#endif
662
   } /* while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) */
663
	fep->cur_rx = bdp;
Linus Torvalds's avatar
Linus Torvalds committed
664
665
666
667
668
669
670
671
672

#if 0
	/* Doing this here will allow us to process all frames in the
	 * ring before the FEC is allowed to put more there.  On a heavily
	 * loaded network, some frames may be lost.  Unfortunately, this
	 * increases the interrupt overhead since we can potentially work
	 * our way back to the interrupt return only to come right back
	 * here.
	 */
673
	fecp->fec_r_des_active = 0;
Linus Torvalds's avatar
Linus Torvalds committed
674
#endif
675
676

	spin_unlock_irq(&fep->hw_lock);
Linus Torvalds's avatar
Linus Torvalds committed
677
678
679
}


680
/* called from interrupt context */
Linus Torvalds's avatar
Linus Torvalds committed
681
682
683
684
685
686
687
static void
fec_enet_mii(struct net_device *dev)
{
	struct	fec_enet_private *fep;
	mii_list_t	*mip;

	fep = netdev_priv(dev);
688
689
	spin_lock_irq(&fep->mii_lock);

Linus Torvalds's avatar
Linus Torvalds committed
690
691
	if ((mip = mii_head) == NULL) {
		printk("MII and no head!\n");
692
		goto unlock;
Linus Torvalds's avatar
Linus Torvalds committed
693
694
695
	}

	if (mip->mii_func != NULL)
Sascha Hauer's avatar
Sascha Hauer committed
696
		(*(mip->mii_func))(readl(fep->hwp + FEC_MII_DATA), dev);
Linus Torvalds's avatar
Linus Torvalds committed
697
698
699
700
701
702

	mii_head = mip->mii_next;
	mip->mii_next = mii_free;
	mii_free = mip;

	if ((mip = mii_head) != NULL)
Sascha Hauer's avatar
Sascha Hauer committed
703
		writel(mip->mii_regval, fep->hwp + FEC_MII_DATA);
704
705

unlock:
706
	spin_unlock_irq(&fep->mii_lock);
Linus Torvalds's avatar
Linus Torvalds committed
707
708
709
710
711
712
713
714
715
716
717
718
719
}

static int
mii_queue(struct net_device *dev, int regval, void (*func)(uint, struct net_device *))
{
	struct fec_enet_private *fep;
	unsigned long	flags;
	mii_list_t	*mip;
	int		retval;

	/* Add PHY address to register command.
	*/
	fep = netdev_priv(dev);
720
	spin_lock_irqsave(&fep->mii_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
721

722
	regval |= fep->phy_addr << 23;
Linus Torvalds's avatar
Linus Torvalds committed
723
724
725
726
727
728
729
730
731
732
	retval = 0;

	if ((mip = mii_free) != NULL) {
		mii_free = mip->mii_next;
		mip->mii_regval = regval;
		mip->mii_func = func;
		mip->mii_next = NULL;
		if (mii_head) {
			mii_tail->mii_next = mip;
			mii_tail = mip;
733
		} else {
Linus Torvalds's avatar
Linus Torvalds committed
734
			mii_head = mii_tail = mip;
Sascha Hauer's avatar
Sascha Hauer committed
735
			writel(regval, fep->hwp + FEC_MII_DATA);
Linus Torvalds's avatar
Linus Torvalds committed
736
		}
737
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
738
739
740
		retval = 1;
	}

741
742
	spin_unlock_irqrestore(&fep->mii_lock, flags);
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
743
744
745
746
747
748
749
}

static void mii_do_cmd(struct net_device *dev, const phy_cmd_t *c)
{
	if(!c)
		return;

750
751
	for (; c->mii_data != mk_mii_end; c++)
		mii_queue(dev, c->mii_data, c->funct);
Linus Torvalds's avatar
Linus Torvalds committed
752
753
754
755
756
757
}

static void mii_parse_sr(uint mii_reg, struct net_device *dev)
{
	struct fec_enet_private *fep = netdev_priv(dev);
	volatile uint *s = &(fep->phy_status);
758
	uint status;
Linus Torvalds's avatar
Linus Torvalds committed
759

760
	status = *s & ~(PHY_STAT_LINK | PHY_STAT_FAULT | PHY_STAT_ANC);
Linus Torvalds's avatar
Linus Torvalds committed
761
762

	if (mii_reg & 0x0004)
763
		status |= PHY_STAT_LINK;
Linus Torvalds's avatar
Linus Torvalds committed
764
	if (mii_reg & 0x0010)
765
		status |= PHY_STAT_FAULT;
Linus Torvalds's avatar
Linus Torvalds committed
766
	if (mii_reg & 0x0020)
767
768
		status |= PHY_STAT_ANC;
	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
769
770
771
772
773
774
}

static void mii_parse_cr(uint mii_reg, struct net_device *dev)
{
	struct fec_enet_private *fep = netdev_priv(dev);
	volatile uint *s = &(fep->phy_status);
775
	uint status;
Linus Torvalds's avatar
Linus Torvalds committed
776

777
	status = *s & ~(PHY_CONF_ANE | PHY_CONF_LOOP);
Linus Torvalds's avatar
Linus Torvalds committed
778
779

	if (mii_reg & 0x1000)
780
		status |= PHY_CONF_ANE;
Linus Torvalds's avatar
Linus Torvalds committed
781
	if (mii_reg & 0x4000)
782
783
		status |= PHY_CONF_LOOP;
	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
784
785
786
787
788
789
}

static void mii_parse_anar(uint mii_reg, struct net_device *dev)
{
	struct fec_enet_private *fep = netdev_priv(dev);
	volatile uint *s = &(fep->phy_status);
790
	uint status;
Linus Torvalds's avatar
Linus Torvalds committed
791

792
	status = *s & ~(PHY_CONF_SPMASK);
Linus Torvalds's avatar
Linus Torvalds committed
793
794

	if (mii_reg & 0x0020)
795
		status |= PHY_CONF_10HDX;
Linus Torvalds's avatar
Linus Torvalds committed
796
	if (mii_reg & 0x0040)
797
		status |= PHY_CONF_10FDX;
Linus Torvalds's avatar
Linus Torvalds committed
798
	if (mii_reg & 0x0080)
799
		status |= PHY_CONF_100HDX;
Linus Torvalds's avatar
Linus Torvalds committed
800
	if (mii_reg & 0x00100)
801
802
		status |= PHY_CONF_100FDX;
	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
}

/* ------------------------------------------------------------------------- */
/* The Level one LXT970 is used by many boards				     */

#define MII_LXT970_MIRROR    16  /* Mirror register           */
#define MII_LXT970_IER       17  /* Interrupt Enable Register */
#define MII_LXT970_ISR       18  /* Interrupt Status Register */
#define MII_LXT970_CONFIG    19  /* Configuration Register    */
#define MII_LXT970_CSR       20  /* Chip Status Register      */

static void mii_parse_lxt970_csr(uint mii_reg, struct net_device *dev)
{
	struct fec_enet_private *fep = netdev_priv(dev);
	volatile uint *s = &(fep->phy_status);
818
	uint status;
Linus Torvalds's avatar
Linus Torvalds committed
819

820
	status = *s & ~(PHY_STAT_SPMASK);
Linus Torvalds's avatar
Linus Torvalds committed
821
822
	if (mii_reg & 0x0800) {
		if (mii_reg & 0x1000)
823
			status |= PHY_STAT_100FDX;
Linus Torvalds's avatar
Linus Torvalds committed
824
		else
825
			status |= PHY_STAT_100HDX;
Linus Torvalds's avatar
Linus Torvalds committed
826
827
	} else {
		if (mii_reg & 0x1000)
828
			status |= PHY_STAT_10FDX;
Linus Torvalds's avatar
Linus Torvalds committed
829
		else
830
			status |= PHY_STAT_10HDX;
Linus Torvalds's avatar
Linus Torvalds committed
831
	}
832
	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
833
834
}

835
static phy_cmd_t const phy_cmd_lxt970_config[] = {
Linus Torvalds's avatar
Linus Torvalds committed
836
837
838
		{ mk_mii_read(MII_REG_CR), mii_parse_cr },
		{ mk_mii_read(MII_REG_ANAR), mii_parse_anar },
		{ mk_mii_end, }
839
840
	};
static phy_cmd_t const phy_cmd_lxt970_startup[] = { /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
841
842
843
		{ mk_mii_write(MII_LXT970_IER, 0x0002), NULL },
		{ mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
		{ mk_mii_end, }
844
845
	};
static phy_cmd_t const phy_cmd_lxt970_ack_int[] = {
Linus Torvalds's avatar
Linus Torvalds committed
846
847
848
849
850
851
852
		/* read SR and ISR to acknowledge */
		{ mk_mii_read(MII_REG_SR), mii_parse_sr },
		{ mk_mii_read(MII_LXT970_ISR), NULL },

		/* find out the current status */
		{ mk_mii_read(MII_LXT970_CSR), mii_parse_lxt970_csr },
		{ mk_mii_end, }
853
854
	};
static phy_cmd_t const phy_cmd_lxt970_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
855
856
		{ mk_mii_write(MII_LXT970_IER, 0x0000), NULL },
		{ mk_mii_end, }
857
858
	};
static phy_info_t const phy_info_lxt970 = {
859
	.id = 0x07810000,
860
861
862
863
864
	.name = "LXT970",
	.config = phy_cmd_lxt970_config,
	.startup = phy_cmd_lxt970_startup,
	.ack_int = phy_cmd_lxt970_ack_int,
	.shutdown = phy_cmd_lxt970_shutdown
Linus Torvalds's avatar
Linus Torvalds committed
865
};
866

Linus Torvalds's avatar
Linus Torvalds committed
867
868
869
870
871
872
873
874
875
876
877
878
/* ------------------------------------------------------------------------- */
/* The Level one LXT971 is used on some of my custom boards                  */

/* register definitions for the 971 */

#define MII_LXT971_PCR       16  /* Port Control Register     */
#define MII_LXT971_SR2       17  /* Status Register 2         */
#define MII_LXT971_IER       18  /* Interrupt Enable Register */
#define MII_LXT971_ISR       19  /* Interrupt Status Register */
#define MII_LXT971_LCR       20  /* LED Control Register      */
#define MII_LXT971_TCR       30  /* Transmit Control Register */

879
/*
Linus Torvalds's avatar
Linus Torvalds committed
880
881
882
883
884
885
886
887
888
 * I had some nice ideas of running the MDIO faster...
 * The 971 should support 8MHz and I tried it, but things acted really
 * weird, so 2.5 MHz ought to be enough for anyone...
 */

static void mii_parse_lxt971_sr2(uint mii_reg, struct net_device *dev)
{
	struct fec_enet_private *fep = netdev_priv(dev);
	volatile uint *s = &(fep->phy_status);
889
	uint status;
Linus Torvalds's avatar
Linus Torvalds committed
890

891
	status = *s & ~(PHY_STAT_SPMASK | PHY_STAT_LINK | PHY_STAT_ANC);
Linus Torvalds's avatar
Linus Torvalds committed
892
893
894

	if (mii_reg & 0x0400) {
		fep->link = 1;
895
		status |= PHY_STAT_LINK;
Linus Torvalds's avatar
Linus Torvalds committed
896
897
898
899
	} else {
		fep->link = 0;
	}
	if (mii_reg & 0x0080)
900
		status |= PHY_STAT_ANC;
Linus Torvalds's avatar
Linus Torvalds committed
901
902
	if (mii_reg & 0x4000) {
		if (mii_reg & 0x0200)
903
			status |= PHY_STAT_100FDX;
Linus Torvalds's avatar
Linus Torvalds committed
904
		else
905
			status |= PHY_STAT_100HDX;
Linus Torvalds's avatar
Linus Torvalds committed
906
907
	} else {
		if (mii_reg & 0x0200)
908
			status |= PHY_STAT_10FDX;
Linus Torvalds's avatar
Linus Torvalds committed
909
		else
910
			status |= PHY_STAT_10HDX;
Linus Torvalds's avatar
Linus Torvalds committed
911
912
	}
	if (mii_reg & 0x0008)
913
		status |= PHY_STAT_FAULT;
Linus Torvalds's avatar
Linus Torvalds committed
914

915
916
	*s = status;
}
917

918
static phy_cmd_t const phy_cmd_lxt971_config[] = {
919
		/* limit to 10MBit because my prototype board
Linus Torvalds's avatar
Linus Torvalds committed
920
921
922
923
924
		 * doesn't work with 100. */
		{ mk_mii_read(MII_REG_CR), mii_parse_cr },
		{ mk_mii_read(MII_REG_ANAR), mii_parse_anar },
		{ mk_mii_read(MII_LXT971_SR2), mii_parse_lxt971_sr2 },
		{ mk_mii_end, }
925
926
	};
static phy_cmd_t const phy_cmd_lxt971_startup[] = {  /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
927
928
929
930
931
932
		{ mk_mii_write(MII_LXT971_IER, 0x00f2), NULL },
		{ mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
		{ mk_mii_write(MII_LXT971_LCR, 0xd422), NULL }, /* LED config */
		/* Somehow does the 971 tell me that the link is down
		 * the first read after power-up.
		 * read here to get a valid value in ack_int */
933
		{ mk_mii_read(MII_REG_SR), mii_parse_sr },
Linus Torvalds's avatar
Linus Torvalds committed
934
		{ mk_mii_end, }
935
936
937
938
	};
static phy_cmd_t const phy_cmd_lxt971_ack_int[] = {
		/* acknowledge the int before reading status ! */
		{ mk_mii_read(MII_LXT971_ISR), NULL },
Linus Torvalds's avatar
Linus Torvalds committed
939
940
941
942
		/* find out the current status */
		{ mk_mii_read(MII_REG_SR), mii_parse_sr },
		{ mk_mii_read(MII_LXT971_SR2), mii_parse_lxt971_sr2 },
		{ mk_mii_end, }
943
944
	};
static phy_cmd_t const phy_cmd_lxt971_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
945
946
		{ mk_mii_write(MII_LXT971_IER, 0x0000), NULL },
		{ mk_mii_end, }
947
948
	};
static phy_info_t const phy_info_lxt971 = {
949
	.id = 0x0001378e,
950
951
952
953
954
	.name = "LXT971",
	.config = phy_cmd_lxt971_config,
	.startup = phy_cmd_lxt971_startup,
	.ack_int = phy_cmd_lxt971_ack_int,
	.shutdown = phy_cmd_lxt971_shutdown
Linus Torvalds's avatar
Linus Torvalds committed
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
};

/* ------------------------------------------------------------------------- */
/* The Quality Semiconductor QS6612 is used on the RPX CLLF                  */

/* register definitions */

#define MII_QS6612_MCR       17  /* Mode Control Register      */
#define MII_QS6612_FTR       27  /* Factory Test Register      */
#define MII_QS6612_MCO       28  /* Misc. Control Register     */
#define MII_QS6612_ISR       29  /* Interrupt Source Register  */
#define MII_QS6612_IMR       30  /* Interrupt Mask Register    */
#define MII_QS6612_PCR       31  /* 100BaseTx PHY Control Reg. */

static void mii_parse_qs6612_pcr(uint mii_reg, struct net_device *dev)
{
	struct fec_enet_private *fep = netdev_priv(dev);
	volatile uint *s = &(fep->phy_status);
973
	uint status;
Linus Torvalds's avatar
Linus Torvalds committed
974

975
	status = *s & ~(PHY_STAT_SPMASK);
Linus Torvalds's avatar
Linus Torvalds committed
976
977

	switch((mii_reg >> 2) & 7) {
978
979
980
981
	case 1: status |= PHY_STAT_10HDX; break;
	case 2: status |= PHY_STAT_100HDX; break;
	case 5: status |= PHY_STAT_10FDX; break;
	case 6: status |= PHY_STAT_100FDX; break;
Linus Torvalds's avatar
Linus Torvalds committed
982
983
}

984
985
986
987
	*s = status;
}

static phy_cmd_t const phy_cmd_qs6612_config[] = {
988
		/* The PHY powers up isolated on the RPX,
Linus Torvalds's avatar
Linus Torvalds committed
989
990
991
992
993
994
995
996
		 * so send a command to allow operation.
		 */
		{ mk_mii_write(MII_QS6612_PCR, 0x0dc0), NULL },

		/* parse cr and anar to get some info */
		{ mk_mii_read(MII_REG_CR), mii_parse_cr },
		{ mk_mii_read(MII_REG_ANAR), mii_parse_anar },
		{ mk_mii_end, }
997
998
	};
static phy_cmd_t const phy_cmd_qs6612_startup[] = {  /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
999
1000
1001
		{ mk_mii_write(MII_QS6612_IMR, 0x003a), NULL },
		{ mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
		{ mk_mii_end, }
1002
1003
	};
static phy_cmd_t const phy_cmd_qs6612_ack_int[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1004
1005
1006
1007
1008
1009
1010
1011
		/* we need to read ISR, SR and ANER to acknowledge */
		{ mk_mii_read(MII_QS6612_ISR), NULL },
		{ mk_mii_read(MII_REG_SR), mii_parse_sr },
		{ mk_mii_read(MII_REG_ANER), NULL },

		/* read pcr to get info */
		{ mk_mii_read(MII_QS6612_PCR), mii_parse_qs6612_pcr },
		{ mk_mii_end, }
1012
1013
	};
static phy_cmd_t const phy_cmd_qs6612_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
1014
1015
		{ mk_mii_write(MII_QS6612_IMR, 0x0000), NULL },
		{ mk_mii_end, }
1016
1017
	};
static phy_info_t const phy_info_qs6612 = {
1018
	.id = 0x00181440,
1019
1020
1021
1022
1023
	.name = "QS6612",
	.config = phy_cmd_qs6612_config,
	.startup = phy_cmd_qs6612_startup,
	.ack_int = phy_cmd_qs6612_ack_int,
	.shutdown = phy_cmd_qs6612_shutdown
Linus Torvalds's avatar
Linus Torvalds committed
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
};

/* ------------------------------------------------------------------------- */
/* AMD AM79C874 phy                                                          */

/* register definitions for the 874 */

#define MII_AM79C874_MFR       16  /* Miscellaneous Feature Register */
#define MII_AM79C874_ICSR      17  /* Interrupt/Status Register      */
#define MII_AM79C874_DR        18  /* Diagnostic Register            */
#define MII_AM79C874_PMLR      19  /* Power and Loopback Register    */
#define MII_AM79C874_MCR       21  /* ModeControl Register           */
#define MII_AM79C874_DC        23  /* Disconnect Counter             */
#define MII_AM79C874_REC       24  /* Recieve Error Counter          */

static void mii_parse_am79c874_dr(uint mii_reg, struct net_device *dev)
{
	struct fec_enet_private *fep = netdev_priv(dev);
	volatile uint *s = &(fep->phy_status);
1043
	uint status;
Linus Torvalds's avatar
Linus Torvalds committed
1044

1045
	status = *s & ~(PHY_STAT_SPMASK | PHY_STAT_ANC);
Linus Torvalds's avatar
Linus Torvalds committed
1046
1047

	if (mii_reg & 0x0080)
1048
		status |= PHY_STAT_ANC;
Linus Torvalds's avatar
Linus Torvalds committed
1049
	if (mii_reg & 0x0400)
1050
		status |= ((mii_reg & 0x0800) ? PHY_STAT_100FDX : PHY_STAT_100HDX);
Linus Torvalds's avatar
Linus Torvalds committed
1051
	else
1052
1053
1054
		status |= ((mii_reg & 0x0800) ? PHY_STAT_10FDX : PHY_STAT_10HDX);

	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
1055
1056
}

1057
static phy_cmd_t const phy_cmd_am79c874_config[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1058
1059
1060
1061
		{ mk_mii_read(MII_REG_CR), mii_parse_cr },
		{ mk_mii_read(MII_REG_ANAR), mii_parse_anar },
		{ mk_mii_read(MII_AM79C874_DR), mii_parse_am79c874_dr },
		{ mk_mii_end, }
1062
1063
	};
static phy_cmd_t const phy_cmd_am79c874_startup[] = {  /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
1064
1065
		{ mk_mii_write(MII_AM79C874_ICSR, 0xff00), NULL },
		{ mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
1066
		{ mk_mii_read(MII_REG_SR), mii_parse_sr },
Linus Torvalds's avatar
Linus Torvalds committed
1067
		{ mk_mii_end, }
1068
1069
	};
static phy_cmd_t const phy_cmd_am79c874_ack_int[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1070
1071
1072
1073
1074
1075
		/* find out the current status */
		{ mk_mii_read(MII_REG_SR), mii_parse_sr },
		{ mk_mii_read(MII_AM79C874_DR), mii_parse_am79c874_dr },
		/* we only need to read ISR to acknowledge */
		{ mk_mii_read(MII_AM79C874_ICSR), NULL },
		{ mk_mii_end, }
1076
1077
	};
static phy_cmd_t const phy_cmd_am79c874_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
1078
1079
		{ mk_mii_write(MII_AM79C874_ICSR, 0x0000), NULL },
		{ mk_mii_end, }
1080
1081
1082
1083
1084
1085
1086
1087
	};
static phy_info_t const phy_info_am79c874 = {
	.id = 0x00022561,
	.name = "AM79C874",
	.config = phy_cmd_am79c874_config,
	.startup = phy_cmd_am79c874_startup,
	.ack_int = phy_cmd_am79c874_ack_int,
	.shutdown = phy_cmd_am79c874_shutdown
Linus Torvalds's avatar
Linus Torvalds committed
1088
1089
};

1090

Linus Torvalds's avatar
Linus Torvalds committed
1091
1092
1093
1094
1095
1096
/* ------------------------------------------------------------------------- */
/* Kendin KS8721BL phy                                                       */

/* register definitions for the 8721 */

#define MII_KS8721BL_RXERCR	21
1097
#define MII_KS8721BL_ICSR	27
Linus Torvalds's avatar
Linus Torvalds committed
1098
1099
#define	MII_KS8721BL_PHYCR	31

1100
static phy_cmd_t const phy_cmd_ks8721bl_config[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1101
1102
1103
		{ mk_mii_read(MII_REG_CR), mii_parse_cr },
		{ mk_mii_read(MII_REG_ANAR), mii_parse_anar },
		{ mk_mii_end, }
1104
1105
	};
static phy_cmd_t const phy_cmd_ks8721bl_startup[] = {  /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
1106
1107
		{ mk_mii_write(MII_KS8721BL_ICSR, 0xff00), NULL },
		{ mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
1108
		{ mk_mii_read(MII_REG_SR), mii_parse_sr },
Linus Torvalds's avatar
Linus Torvalds committed
1109
		{ mk_mii_end, }
1110
1111
	};
static phy_cmd_t const phy_cmd_ks8721bl_ack_int[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1112
1113
1114
1115
1116
		/* find out the current status */
		{ mk_mii_read(MII_REG_SR), mii_parse_sr },
		/* we only need to read ISR to acknowledge */
		{ mk_mii_read(MII_KS8721BL_ICSR), NULL },
		{ mk_mii_end, }
1117
1118
	};
static phy_cmd_t const phy_cmd_ks8721bl_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
1119
1120
		{ mk_mii_write(MII_KS8721BL_ICSR, 0x0000), NULL },
		{ mk_mii_end, }
1121
1122
	};
static phy_info_t const phy_info_ks8721bl = {
1123
	.id = 0x00022161,
1124
1125
1126
1127
1128
	.name = "KS8721BL",
	.config = phy_cmd_ks8721bl_config,
	.startup = phy_cmd_ks8721bl_startup,
	.ack_int = phy_cmd_ks8721bl_ack_int,
	.shutdown = phy_cmd_ks8721bl_shutdown
Linus Torvalds's avatar
Linus Torvalds committed
1129
1130
};

1131
1132
1133
1134
1135
1136
1137
/* ------------------------------------------------------------------------- */
/* register definitions for the DP83848 */

#define MII_DP8384X_PHYSTST    16  /* PHY Status Register */

static void mii_parse_dp8384x_sr2(uint mii_reg, struct net_device *dev)
{
1138
	struct fec_enet_private *fep = netdev_priv(dev);
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
	volatile uint *s = &(fep->phy_status);

	*s &= ~(PHY_STAT_SPMASK | PHY_STAT_LINK | PHY_STAT_ANC);

	/* Link up */
	if (mii_reg & 0x0001) {
		fep->link = 1;
		*s |= PHY_STAT_LINK;
	} else
		fep->link = 0;
	/* Status of link */
	if (mii_reg & 0x0010)   /* Autonegotioation complete */
		*s |= PHY_STAT_ANC;
	if (mii_reg & 0x0002) {   /* 10MBps? */
		if (mii_reg & 0x0004)   /* Full Duplex? */
			*s |= PHY_STAT_10FDX;
		else
			*s |= PHY_STAT_10HDX;
	} else {                  /* 100 Mbps? */
		if (mii_reg & 0x0004)   /* Full Duplex? */
			*s |= PHY_STAT_100FDX;
		else
			*s |= PHY_STAT_100HDX;
	}
	if (mii_reg & 0x0008)
		*s |= PHY_STAT_FAULT;
}

static phy_info_t phy_info_dp83848= {
	0x020005c9,
	"DP83848",

	(const phy_cmd_t []) {  /* config */
		{ mk_mii_read(MII_REG_CR), mii_parse_cr },
		{ mk_mii_read(MII_REG_ANAR), mii_parse_anar },
		{ mk_mii_read(MII_DP8384X_PHYSTST), mii_parse_dp8384x_sr2 },
		{ mk_mii_end, }
	},
	(const phy_cmd_t []) {  /* startup - enable interrupts */
		{ mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
		{ mk_mii_read(MII_REG_SR), mii_parse_sr },
		{ mk_mii_end, }
	},
	(const phy_cmd_t []) { /* ack_int - never happens, no interrupt */
		{ mk_mii_end, }
	},
	(const phy_cmd_t []) {  /* shutdown */
		{ mk_mii_end, }
	},
};

Linus Torvalds's avatar
Linus Torvalds committed
1190
1191
/* ------------------------------------------------------------------------- */

1192
static phy_info_t const * const phy_info[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1193
1194
1195
1196
1197
	&phy_info_lxt970,
	&phy_info_lxt971,
	&phy_info_qs6612,
	&phy_info_am79c874,
	&phy_info_ks8721bl,
1198
	&phy_info_dp83848,
Linus Torvalds's avatar
Linus Torvalds committed
1199
1200
1201
1202
	NULL
};

/* ------------------------------------------------------------------------- */
1203
#ifdef HAVE_mii_link_interrupt
Linus Torvalds's avatar
Linus Torvalds committed
1204
static irqreturn_t
1205
mii_link_interrupt(int irq, void * dev_id);
Linus Torvalds's avatar
Linus Torvalds committed
1206
1207

/*
1208
 *	This is specific to the MII interrupt setup of the M5272EVB.
Linus Torvalds's avatar
Linus Torvalds committed
1209
 */
1210
static void __inline__ fec_request_mii_intr(struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
1211
{
1212
1213
	if (request_irq(66, mii_link_interrupt, IRQF_DISABLED, "fec(MII)", dev) != 0)
		printk("FEC: Could not allocate fec(MII) IRQ(66)!\n");
Linus Torvalds's avatar
Linus Torvalds committed
1214
1215
1216
1217
1218
1219
}

static void __inline__ fec_disable_phy_intr(void)
{
	volatile unsigned long *icrp;
	icrp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_ICR1);
1220
	*icrp = 0x08000000;
Linus Torvalds's avatar
Linus Torvalds committed
1221
1222
1223
1224
1225
1226
1227
}

static void __inline__ fec_phy_ack_intr(void)
{
	volatile unsigned long *icrp;
	/* Acknowledge the interrupt */
	icrp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_ICR1);