fec.c 54.5 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

Sascha Hauer's avatar
Sascha Hauer committed
89
/* Forward declarations of some structures to support different PHYs */
Linus Torvalds's avatar
Linus Torvalds committed
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

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 */

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

Sascha Hauer's avatar
Sascha Hauer committed
125
/* Interrupt events/masks. */
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
#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


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

Greg Ungerer's avatar
Greg Ungerer committed
168
169
	struct net_device *netdev;

170
171
	struct clk *clk;

Linus Torvalds's avatar
Linus Torvalds committed
172
173
174
175
176
177
	/* 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;

Sascha Hauer's avatar
Sascha Hauer committed
178
	/* CPM dual port RAM relative addresses */
179
	dma_addr_t	bd_dma;
Sascha Hauer's avatar
Sascha Hauer committed
180
	/* Address of Rx and Tx buffers */
181
182
183
184
	struct bufdesc	*rx_bd_base;
	struct bufdesc	*tx_bd_base;
	/* The next free ring entry */
	struct bufdesc	*cur_rx, *cur_tx; 
Sascha Hauer's avatar
Sascha Hauer committed
185
	/* The ring entries to be free()ed */
186
187
	struct bufdesc	*dirty_tx;

Linus Torvalds's avatar
Linus Torvalds committed
188
	uint	tx_full;
189
190
191
192
	/* 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
193
194
195
196
197

	uint	phy_id;
	uint	phy_id_done;
	uint	phy_status;
	uint	phy_speed;
198
	phy_info_t const	*phy;
Linus Torvalds's avatar
Linus Torvalds committed
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
	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);
216
static irqreturn_t fec_enet_interrupt(int irq, void * dev_id);
Linus Torvalds's avatar
Linus Torvalds committed
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
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
237
238
239
240
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
241

242
static int	mii_queue(struct net_device *dev, int request,
Linus Torvalds's avatar
Linus Torvalds committed
243
244
				void (*func)(uint, struct net_device *));

Sascha Hauer's avatar
Sascha Hauer committed
245
/* Make MII read/write commands for the FEC */
Linus Torvalds's avatar
Linus Torvalds committed
246
247
248
249
250
#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

Sascha Hauer's avatar
Sascha Hauer committed
251
252
/* Transmitter timeout */
#define TX_TIMEOUT (2 * HZ)
Linus Torvalds's avatar
Linus Torvalds committed
253

Sascha Hauer's avatar
Sascha Hauer committed
254
/* Register definitions for the PHY */
Linus Torvalds's avatar
Linus Torvalds committed
255
256
257
258
259

#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            */
260
#define MII_REG_ANAR        4  /* A-N Advertisement Register               */
Linus Torvalds's avatar
Linus Torvalds committed
261
262
263
264
265
266
267
268
269
270
271
#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 */
272
#define PHY_CONF_10FDX	0x0020  /* 10 Mbit full duplex supported */
Linus Torvalds's avatar
Linus Torvalds committed
273
#define PHY_CONF_100HDX	0x0040  /* 100 Mbit half duplex supported */
274
#define PHY_CONF_100FDX	0x0080  /* 100 Mbit full duplex supported */
Linus Torvalds's avatar
Linus Torvalds committed
275
276
277
278
279
280

#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	*/
281
#define PHY_STAT_10FDX	0x2000  /* 10 Mbit full duplex selected	*/
Linus Torvalds's avatar
Linus Torvalds committed
282
#define PHY_STAT_100HDX	0x4000  /* 100 Mbit half duplex selected */
283
#define PHY_STAT_100FDX	0x8000  /* 100 Mbit full duplex selected */
Linus Torvalds's avatar
Linus Torvalds committed
284
285
286
287
288


static int
fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
Sascha Hauer's avatar
Sascha Hauer committed
289
	struct fec_enet_private *fep = netdev_priv(dev);
290
	struct bufdesc *bdp;
291
	unsigned short	status;
292
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
293
294
295
296
297
298

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

299
	spin_lock_irqsave(&fep->hw_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
300
301
302
	/* Fill in a Tx ring entry */
	bdp = fep->cur_tx;

303
	status = bdp->cbd_sc;
Sascha Hauer's avatar
Sascha Hauer committed
304

305
	if (status & BD_ENET_TX_READY) {
Linus Torvalds's avatar
Linus Torvalds committed
306
307
308
309
		/* 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);
310
		spin_unlock_irqrestore(&fep->hw_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
311
312
313
		return 1;
	}

Sascha Hauer's avatar
Sascha Hauer committed
314
	/* Clear all of the status flags */
315
	status &= ~BD_ENET_TX_STATS;
Linus Torvalds's avatar
Linus Torvalds committed
316

Sascha Hauer's avatar
Sascha Hauer committed
317
	/* Set buffer length and buffer pointer */
Linus Torvalds's avatar
Linus Torvalds committed
318
319
320
321
	bdp->cbd_bufaddr = __pa(skb->data);
	bdp->cbd_datlen = skb->len;

	/*
Sascha Hauer's avatar
Sascha Hauer committed
322
323
324
	 * On some FEC implementations data must be aligned on
	 * 4-byte boundaries. Use bounce buffers to copy data
	 * and get it aligned. Ugh.
Linus Torvalds's avatar
Linus Torvalds committed
325
	 */
326
	if (bdp->cbd_bufaddr & FEC_ALIGNMENT) {
Linus Torvalds's avatar
Linus Torvalds committed
327
328
		unsigned int index;
		index = bdp - fep->tx_bd_base;
329
		memcpy(fep->tx_bounce[index], (void *)skb->data, skb->len);
Linus Torvalds's avatar
Linus Torvalds committed
330
331
332
		bdp->cbd_bufaddr = __pa(fep->tx_bounce[index]);
	}

Sascha Hauer's avatar
Sascha Hauer committed
333
	/* Save skb pointer */
Linus Torvalds's avatar
Linus Torvalds committed
334
335
	fep->tx_skbuff[fep->skb_cur] = skb;

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

Linus Torvalds's avatar
Linus Torvalds committed
339
340
341
	/* Push the data cache so the CPM does not get stale memory
	 * data.
	 */
342
343
	dma_sync_single(NULL, bdp->cbd_bufaddr,
			bdp->cbd_datlen, DMA_TO_DEVICE);
Linus Torvalds's avatar
Linus Torvalds committed
344

345
346
	/* 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
347
	 */
348
	status |= (BD_ENET_TX_READY | BD_ENET_TX_INTR
Linus Torvalds's avatar
Linus Torvalds committed
349
			| BD_ENET_TX_LAST | BD_ENET_TX_TC);
350
	bdp->cbd_sc = status;
Linus Torvalds's avatar
Linus Torvalds committed
351
352
353
354

	dev->trans_start = jiffies;

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

Sascha Hauer's avatar
Sascha Hauer committed
357
358
	/* If this was the last BD in the ring, start at the beginning again. */
	if (status & BD_ENET_TX_WRAP)
Linus Torvalds's avatar
Linus Torvalds committed
359
		bdp = fep->tx_bd_base;
Sascha Hauer's avatar
Sascha Hauer committed
360
	else
Linus Torvalds's avatar
Linus Torvalds committed
361
362
363
364
365
366
367
		bdp++;

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

368
	fep->cur_tx = bdp;
Linus Torvalds's avatar
Linus Torvalds committed
369

370
	spin_unlock_irqrestore(&fep->hw_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
371
372
373
374
375
376
377
378
379
380

	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);
381
	dev->stats.tx_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
382
383
384
#ifndef final_version
	{
	int	i;
385
	struct bufdesc *bdp;
Linus Torvalds's avatar
Linus Torvalds committed
386
387
388
389
390
391
392
393
394

	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++) {
395
		printk("  %08x: %04x %04x %08x\n",
Linus Torvalds's avatar
Linus Torvalds committed
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
		       (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
415
	fec_restart(dev, fep->full_duplex);
Linus Torvalds's avatar
Linus Torvalds committed
416
417
418
419
	netif_wake_queue(dev);
}

static irqreturn_t
420
fec_enet_interrupt(int irq, void * dev_id)
Linus Torvalds's avatar
Linus Torvalds committed
421
422
{
	struct	net_device *dev = dev_id;
Sascha Hauer's avatar
Sascha Hauer committed
423
	struct fec_enet_private *fep = netdev_priv(dev);
Linus Torvalds's avatar
Linus Torvalds committed
424
	uint	int_events;
425
	irqreturn_t ret = IRQ_NONE;
Linus Torvalds's avatar
Linus Torvalds committed
426

427
	do {
Sascha Hauer's avatar
Sascha Hauer committed
428
429
		int_events = readl(fep->hwp + FEC_IEVENT);
		writel(int_events, fep->hwp + FEC_IEVENT);
Linus Torvalds's avatar
Linus Torvalds committed
430
431

		if (int_events & FEC_ENET_RXF) {
432
			ret = IRQ_HANDLED;
Linus Torvalds's avatar
Linus Torvalds committed
433
434
435
436
			fec_enet_rx(dev);
		}

		/* Transmit OK, or non-fatal error. Update the buffer
Sascha Hauer's avatar
Sascha Hauer committed
437
438
439
		 * descriptors. FEC handles all errors, we just discover
		 * them as part of the transmit process.
		 */
Linus Torvalds's avatar
Linus Torvalds committed
440
		if (int_events & FEC_ENET_TXF) {
441
			ret = IRQ_HANDLED;
Linus Torvalds's avatar
Linus Torvalds committed
442
443
444
445
			fec_enet_tx(dev);
		}

		if (int_events & FEC_ENET_MII) {
446
			ret = IRQ_HANDLED;
Linus Torvalds's avatar
Linus Torvalds committed
447
448
			fec_enet_mii(dev);
		}
449

450
451
452
	} while (int_events);

	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
453
454
455
456
457
458
459
}


static void
fec_enet_tx(struct net_device *dev)
{
	struct	fec_enet_private *fep;
460
	struct bufdesc *bdp;
461
	unsigned short status;
Linus Torvalds's avatar
Linus Torvalds committed
462
463
464
	struct	sk_buff	*skb;

	fep = netdev_priv(dev);
465
	spin_lock_irq(&fep->hw_lock);
Linus Torvalds's avatar
Linus Torvalds committed
466
467
	bdp = fep->dirty_tx;

468
	while (((status = bdp->cbd_sc) & BD_ENET_TX_READY) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
469
470
471
472
		if (bdp == fep->cur_tx && fep->tx_full == 0) break;

		skb = fep->tx_skbuff[fep->skb_dirty];
		/* Check for errors. */
473
		if (status & (BD_ENET_TX_HB | BD_ENET_TX_LC |
Linus Torvalds's avatar
Linus Torvalds committed
474
475
				   BD_ENET_TX_RL | BD_ENET_TX_UN |
				   BD_ENET_TX_CSL)) {
476
			dev->stats.tx_errors++;
477
			if (status & BD_ENET_TX_HB)  /* No heartbeat */
478
				dev->stats.tx_heartbeat_errors++;
479
			if (status & BD_ENET_TX_LC)  /* Late collision */
480
				dev->stats.tx_window_errors++;
481
			if (status & BD_ENET_TX_RL)  /* Retrans limit */
482
				dev->stats.tx_aborted_errors++;
483
			if (status & BD_ENET_TX_UN)  /* Underrun */
484
				dev->stats.tx_fifo_errors++;
485
			if (status & BD_ENET_TX_CSL) /* Carrier lost */
486
				dev->stats.tx_carrier_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
487
		} else {
488
			dev->stats.tx_packets++;
Linus Torvalds's avatar
Linus Torvalds committed
489
490
		}

491
		if (status & BD_ENET_TX_READY)
Linus Torvalds's avatar
Linus Torvalds committed
492
			printk("HEY! Enet xmit interrupt and TX_READY.\n");
Sascha Hauer's avatar
Sascha Hauer committed
493

Linus Torvalds's avatar
Linus Torvalds committed
494
495
496
		/* Deferred means some collisions occurred during transmit,
		 * but we eventually sent the packet OK.
		 */
497
		if (status & BD_ENET_TX_DEF)
498
			dev->stats.collisions++;
499

Sascha Hauer's avatar
Sascha Hauer committed
500
		/* Free the sk buffer associated with this last transmit */
Linus Torvalds's avatar
Linus Torvalds committed
501
502
503
		dev_kfree_skb_any(skb);
		fep->tx_skbuff[fep->skb_dirty] = NULL;
		fep->skb_dirty = (fep->skb_dirty + 1) & TX_RING_MOD_MASK;
504

Sascha Hauer's avatar
Sascha Hauer committed
505
		/* Update pointer to next buffer descriptor to be transmitted */
506
		if (status & BD_ENET_TX_WRAP)
Linus Torvalds's avatar
Linus Torvalds committed
507
508
509
			bdp = fep->tx_bd_base;
		else
			bdp++;
510

Sascha Hauer's avatar
Sascha Hauer committed
511
		/* Since we have freed up a buffer, the ring is no longer full
Linus Torvalds's avatar
Linus Torvalds committed
512
513
514
515
516
517
518
		 */
		if (fep->tx_full) {
			fep->tx_full = 0;
			if (netif_queue_stopped(dev))
				netif_wake_queue(dev);
		}
	}
519
	fep->dirty_tx = bdp;
520
	spin_unlock_irq(&fep->hw_lock);
Linus Torvalds's avatar
Linus Torvalds committed
521
522
523
524
525
526
527
528
529
530
531
}


/* 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
532
	struct	fec_enet_private *fep = netdev_priv(dev);
533
	struct bufdesc *bdp;
534
	unsigned short status;
Linus Torvalds's avatar
Linus Torvalds committed
535
536
537
	struct	sk_buff	*skb;
	ushort	pkt_len;
	__u8 *data;
538

539
540
#ifdef CONFIG_M532x
	flush_cache_all();
541
#endif
Linus Torvalds's avatar
Linus Torvalds committed
542

543
544
	spin_lock_irq(&fep->hw_lock);

Linus Torvalds's avatar
Linus Torvalds committed
545
546
547
548
549
	/* 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;

Sascha Hauer's avatar
Sascha Hauer committed
550
	while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) {
Linus Torvalds's avatar
Linus Torvalds committed
551

Sascha Hauer's avatar
Sascha Hauer committed
552
553
554
555
556
		/* Since we have allocated space to hold a complete frame,
		 * the last indicator should be set.
		 */
		if ((status & BD_ENET_RX_LAST) == 0)
			printk("FEC ENET: rcv is not +last\n");
Linus Torvalds's avatar
Linus Torvalds committed
557

Sascha Hauer's avatar
Sascha Hauer committed
558
559
		if (!fep->opened)
			goto rx_processing_done;
Linus Torvalds's avatar
Linus Torvalds committed
560

Sascha Hauer's avatar
Sascha Hauer committed
561
562
		/* Check for errors. */
		if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
Linus Torvalds's avatar
Linus Torvalds committed
563
			   BD_ENET_RX_CR | BD_ENET_RX_OV)) {
Sascha Hauer's avatar
Sascha Hauer committed
564
565
566
567
568
569
570
571
572
573
574
			dev->stats.rx_errors++;
			if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH)) {
				/* Frame too long or too short. */
				dev->stats.rx_length_errors++;
			}
			if (status & BD_ENET_RX_NO)	/* Frame alignment */
				dev->stats.rx_frame_errors++;
			if (status & BD_ENET_RX_CR)	/* CRC Error */
				dev->stats.rx_crc_errors++;
			if (status & BD_ENET_RX_OV)	/* FIFO overrun */
				dev->stats.rx_fifo_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
575
576
		}

Sascha Hauer's avatar
Sascha Hauer committed
577
578
579
580
581
582
583
584
585
		/* 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.
		 */
		if (status & BD_ENET_RX_CL) {
			dev->stats.rx_errors++;
			dev->stats.rx_frame_errors++;
			goto rx_processing_done;
		}
Linus Torvalds's avatar
Linus Torvalds committed
586

Sascha Hauer's avatar
Sascha Hauer committed
587
588
589
590
591
		/* Process the incoming frame. */
		dev->stats.rx_packets++;
		pkt_len = bdp->cbd_datlen;
		dev->stats.rx_bytes += pkt_len;
		data = (__u8*)__va(bdp->cbd_bufaddr);
Linus Torvalds's avatar
Linus Torvalds committed
592

Sascha Hauer's avatar
Sascha Hauer committed
593
		dma_sync_single(NULL, (unsigned long)__pa(data),
594
595
			pkt_len - 4, DMA_FROM_DEVICE);

Sascha Hauer's avatar
Sascha Hauer committed
596
597
598
599
600
601
		/* 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);
Linus Torvalds's avatar
Linus Torvalds committed
602

Sascha Hauer's avatar
Sascha Hauer committed
603
604
605
606
607
608
609
610
611
612
613
614
615
		if (skb == NULL) {
			printk("%s: Memory squeeze, dropping packet.\n",
					dev->name);
			dev->stats.rx_dropped++;
		} else {
			skb_put(skb, pkt_len - 4);	/* Make room */
			skb_copy_to_linear_data(skb, data, pkt_len - 4);
			skb->protocol = eth_type_trans(skb, dev);
			netif_rx(skb);
		}
rx_processing_done:
		/* Clear the status flags for this buffer */
		status &= ~BD_ENET_RX_STATS;
Linus Torvalds's avatar
Linus Torvalds committed
616

Sascha Hauer's avatar
Sascha Hauer committed
617
618
619
		/* Mark the buffer empty */
		status |= BD_ENET_RX_EMPTY;
		bdp->cbd_sc = status;
620

Sascha Hauer's avatar
Sascha Hauer committed
621
622
623
624
625
626
627
628
629
630
631
		/* Update BD pointer to next entry */
		if (status & BD_ENET_RX_WRAP)
			bdp = fep->rx_bd_base;
		else
			bdp++;
		/* 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.
		 */
		writel(0, fep->hwp + FEC_R_DES_ACTIVE);
	}
632
	fep->cur_rx = bdp;
Linus Torvalds's avatar
Linus Torvalds committed
633

634
	spin_unlock_irq(&fep->hw_lock);
Linus Torvalds's avatar
Linus Torvalds committed
635
636
}

637
/* called from interrupt context */
Linus Torvalds's avatar
Linus Torvalds committed
638
639
640
641
642
643
644
static void
fec_enet_mii(struct net_device *dev)
{
	struct	fec_enet_private *fep;
	mii_list_t	*mip;

	fep = netdev_priv(dev);
645
646
	spin_lock_irq(&fep->mii_lock);

Linus Torvalds's avatar
Linus Torvalds committed
647
648
	if ((mip = mii_head) == NULL) {
		printk("MII and no head!\n");
649
		goto unlock;
Linus Torvalds's avatar
Linus Torvalds committed
650
651
652
	}

	if (mip->mii_func != NULL)
Sascha Hauer's avatar
Sascha Hauer committed
653
		(*(mip->mii_func))(readl(fep->hwp + FEC_MII_DATA), dev);
Linus Torvalds's avatar
Linus Torvalds committed
654
655
656
657
658
659

	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
660
		writel(mip->mii_regval, fep->hwp + FEC_MII_DATA);
661
662

unlock:
663
	spin_unlock_irq(&fep->mii_lock);
Linus Torvalds's avatar
Linus Torvalds committed
664
665
666
667
668
669
670
671
672
673
}

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;

Sascha Hauer's avatar
Sascha Hauer committed
674
	/* Add PHY address to register command */
Linus Torvalds's avatar
Linus Torvalds committed
675
	fep = netdev_priv(dev);
676
	spin_lock_irqsave(&fep->mii_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
677

678
	regval |= fep->phy_addr << 23;
Linus Torvalds's avatar
Linus Torvalds committed
679
680
681
682
683
684
685
686
687
688
	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;
689
		} else {
Linus Torvalds's avatar
Linus Torvalds committed
690
			mii_head = mii_tail = mip;
Sascha Hauer's avatar
Sascha Hauer committed
691
			writel(regval, fep->hwp + FEC_MII_DATA);
Linus Torvalds's avatar
Linus Torvalds committed
692
		}
693
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
694
695
696
		retval = 1;
	}

697
698
	spin_unlock_irqrestore(&fep->mii_lock, flags);
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
699
700
701
702
703
704
705
}

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

706
707
	for (; c->mii_data != mk_mii_end; c++)
		mii_queue(dev, c->mii_data, c->funct);
Linus Torvalds's avatar
Linus Torvalds committed
708
709
710
711
712
713
}

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);
714
	uint status;
Linus Torvalds's avatar
Linus Torvalds committed
715

716
	status = *s & ~(PHY_STAT_LINK | PHY_STAT_FAULT | PHY_STAT_ANC);
Linus Torvalds's avatar
Linus Torvalds committed
717
718

	if (mii_reg & 0x0004)
719
		status |= PHY_STAT_LINK;
Linus Torvalds's avatar
Linus Torvalds committed
720
	if (mii_reg & 0x0010)
721
		status |= PHY_STAT_FAULT;
Linus Torvalds's avatar
Linus Torvalds committed
722
	if (mii_reg & 0x0020)
723
724
		status |= PHY_STAT_ANC;
	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
725
726
727
728
729
730
}

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);
731
	uint status;
Linus Torvalds's avatar
Linus Torvalds committed
732

733
	status = *s & ~(PHY_CONF_ANE | PHY_CONF_LOOP);
Linus Torvalds's avatar
Linus Torvalds committed
734
735

	if (mii_reg & 0x1000)
736
		status |= PHY_CONF_ANE;
Linus Torvalds's avatar
Linus Torvalds committed
737
	if (mii_reg & 0x4000)
738
739
		status |= PHY_CONF_LOOP;
	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
740
741
742
743
744
745
}

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);
746
	uint status;
Linus Torvalds's avatar
Linus Torvalds committed
747

748
	status = *s & ~(PHY_CONF_SPMASK);
Linus Torvalds's avatar
Linus Torvalds committed
749
750

	if (mii_reg & 0x0020)
751
		status |= PHY_CONF_10HDX;
Linus Torvalds's avatar
Linus Torvalds committed
752
	if (mii_reg & 0x0040)
753
		status |= PHY_CONF_10FDX;
Linus Torvalds's avatar
Linus Torvalds committed
754
	if (mii_reg & 0x0080)
755
		status |= PHY_CONF_100HDX;
Linus Torvalds's avatar
Linus Torvalds committed
756
	if (mii_reg & 0x00100)
757
758
		status |= PHY_CONF_100FDX;
	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
}

/* ------------------------------------------------------------------------- */
/* 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);
774
	uint status;
Linus Torvalds's avatar
Linus Torvalds committed
775

776
	status = *s & ~(PHY_STAT_SPMASK);
Linus Torvalds's avatar
Linus Torvalds committed
777
778
	if (mii_reg & 0x0800) {
		if (mii_reg & 0x1000)
779
			status |= PHY_STAT_100FDX;
Linus Torvalds's avatar
Linus Torvalds committed
780
		else
781
			status |= PHY_STAT_100HDX;
Linus Torvalds's avatar
Linus Torvalds committed
782
783
	} else {
		if (mii_reg & 0x1000)
784
			status |= PHY_STAT_10FDX;
Linus Torvalds's avatar
Linus Torvalds committed
785
		else
786
			status |= PHY_STAT_10HDX;
Linus Torvalds's avatar
Linus Torvalds committed
787
	}
788
	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
789
790
}

791
static phy_cmd_t const phy_cmd_lxt970_config[] = {
Linus Torvalds's avatar
Linus Torvalds committed
792
793
794
		{ mk_mii_read(MII_REG_CR), mii_parse_cr },
		{ mk_mii_read(MII_REG_ANAR), mii_parse_anar },
		{ mk_mii_end, }
795
796
	};
static phy_cmd_t const phy_cmd_lxt970_startup[] = { /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
797
798
799
		{ mk_mii_write(MII_LXT970_IER, 0x0002), NULL },
		{ mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
		{ mk_mii_end, }
800
801
	};
static phy_cmd_t const phy_cmd_lxt970_ack_int[] = {
Linus Torvalds's avatar
Linus Torvalds committed
802
803
804
805
806
807
808
		/* 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, }
809
810
	};
static phy_cmd_t const phy_cmd_lxt970_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
811
812
		{ mk_mii_write(MII_LXT970_IER, 0x0000), NULL },
		{ mk_mii_end, }
813
814
	};
static phy_info_t const phy_info_lxt970 = {
815
	.id = 0x07810000,
816
817
818
819
820
	.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
821
};
822

Linus Torvalds's avatar
Linus Torvalds committed
823
824
825
826
827
828
829
830
831
832
833
834
/* ------------------------------------------------------------------------- */
/* 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 */

835
/*
Linus Torvalds's avatar
Linus Torvalds committed
836
837
838
839
840
841
842
843
844
 * 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);
845
	uint status;
Linus Torvalds's avatar
Linus Torvalds committed
846

847
	status = *s & ~(PHY_STAT_SPMASK | PHY_STAT_LINK | PHY_STAT_ANC);
Linus Torvalds's avatar
Linus Torvalds committed
848
849
850

	if (mii_reg & 0x0400) {
		fep->link = 1;
851
		status |= PHY_STAT_LINK;
Linus Torvalds's avatar
Linus Torvalds committed
852
853
854
855
	} else {
		fep->link = 0;
	}
	if (mii_reg & 0x0080)
856
		status |= PHY_STAT_ANC;
Linus Torvalds's avatar
Linus Torvalds committed
857
858
	if (mii_reg & 0x4000) {
		if (mii_reg & 0x0200)
859
			status |= PHY_STAT_100FDX;
Linus Torvalds's avatar
Linus Torvalds committed
860
		else
861
			status |= PHY_STAT_100HDX;
Linus Torvalds's avatar
Linus Torvalds committed
862
863
	} else {
		if (mii_reg & 0x0200)
864
			status |= PHY_STAT_10FDX;
Linus Torvalds's avatar
Linus Torvalds committed
865
		else
866
			status |= PHY_STAT_10HDX;
Linus Torvalds's avatar
Linus Torvalds committed
867
868
	}
	if (mii_reg & 0x0008)
869
		status |= PHY_STAT_FAULT;
Linus Torvalds's avatar
Linus Torvalds committed
870

871
872
	*s = status;
}
873

874
static phy_cmd_t const phy_cmd_lxt971_config[] = {
875
		/* limit to 10MBit because my prototype board
Linus Torvalds's avatar
Linus Torvalds committed
876
877
878
879
880
		 * 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, }
881
882
	};
static phy_cmd_t const phy_cmd_lxt971_startup[] = {  /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
883
884
885
886
887
888
		{ 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 */
889
		{ mk_mii_read(MII_REG_SR), mii_parse_sr },
Linus Torvalds's avatar
Linus Torvalds committed
890
		{ mk_mii_end, }
891
892
893
894
	};
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
895
896
897
898
		/* 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, }
899
900
	};
static phy_cmd_t const phy_cmd_lxt971_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
901
902
		{ mk_mii_write(MII_LXT971_IER, 0x0000), NULL },
		{ mk_mii_end, }
903
904
	};
static phy_info_t const phy_info_lxt971 = {
905
	.id = 0x0001378e,
906
907
908
909
910
	.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
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
};

/* ------------------------------------------------------------------------- */
/* 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);
929
	uint status;
Linus Torvalds's avatar
Linus Torvalds committed
930

931
	status = *s & ~(PHY_STAT_SPMASK);
Linus Torvalds's avatar
Linus Torvalds committed
932
933

	switch((mii_reg >> 2) & 7) {
934
935
936
937
	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
938
939
}

940
941
942
943
	*s = status;
}

static phy_cmd_t const phy_cmd_qs6612_config[] = {
944
		/* The PHY powers up isolated on the RPX,
Linus Torvalds's avatar
Linus Torvalds committed
945
946
947
948
949
950
951
952
		 * 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, }
953
954
	};
static phy_cmd_t const phy_cmd_qs6612_startup[] = {  /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
955
956
957
		{ mk_mii_write(MII_QS6612_IMR, 0x003a), NULL },
		{ mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
		{ mk_mii_end, }
958
959
	};
static phy_cmd_t const phy_cmd_qs6612_ack_int[] = {
Linus Torvalds's avatar
Linus Torvalds committed
960
961
962
963
964
965
966
967
		/* 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, }
968
969
	};
static phy_cmd_t const phy_cmd_qs6612_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
970
971
		{ mk_mii_write(MII_QS6612_IMR, 0x0000), NULL },
		{ mk_mii_end, }
972
973
	};
static phy_info_t const phy_info_qs6612 = {
974
	.id = 0x00181440,
975
976
977
978
979
	.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
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
};

/* ------------------------------------------------------------------------- */
/* 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);
999
	uint status;
Linus Torvalds's avatar
Linus Torvalds committed
1000

1001
	status = *s & ~(PHY_STAT_SPMASK | PHY_STAT_ANC);
Linus Torvalds's avatar
Linus Torvalds committed
1002
1003

	if (mii_reg & 0x0080)
1004
		status |= PHY_STAT_ANC;
Linus Torvalds's avatar
Linus Torvalds committed
1005
	if (mii_reg & 0x0400)
1006
		status |= ((mii_reg & 0x0800) ? PHY_STAT_100FDX : PHY_STAT_100HDX);
Linus Torvalds's avatar
Linus Torvalds committed
1007
	else
1008
1009
1010
		status |= ((mii_reg & 0x0800) ? PHY_STAT_10FDX : PHY_STAT_10HDX);

	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
1011
1012
}

1013
static phy_cmd_t const phy_cmd_am79c874_config[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1014
1015
1016
1017
		{ 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, }
1018
1019
	};
static phy_cmd_t const phy_cmd_am79c874_startup[] = {  /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
1020
1021
		{ mk_mii_write(MII_AM79C874_ICSR, 0xff00), NULL },
		{ mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
1022
		{ mk_mii_read(MII_REG_SR), mii_parse_sr },
Linus Torvalds's avatar
Linus Torvalds committed
1023
		{ mk_mii_end, }
1024
1025
	};
static phy_cmd_t const phy_cmd_am79c874_ack_int[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1026
1027
1028
1029
1030
1031
		/* 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, }
1032
1033
	};
static phy_cmd_t const phy_cmd_am79c874_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
1034
1035
		{ mk_mii_write(MII_AM79C874_ICSR, 0x0000), NULL },
		{ mk_mii_end, }
1036
1037
1038
1039
1040
1041
1042
1043
	};
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
1044
1045
};

1046

Linus Torvalds's avatar
Linus Torvalds committed
1047
1048
1049
1050
1051
1052
/* ------------------------------------------------------------------------- */
/* Kendin KS8721BL phy                                                       */

/* register definitions for the 8721 */

#define MII_KS8721BL_RXERCR	21
1053
#define MII_KS8721BL_ICSR	27
Linus Torvalds's avatar
Linus Torvalds committed
1054
1055
#define	MII_KS8721BL_PHYCR	31

1056
static phy_cmd_t const phy_cmd_ks8721bl_config[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1057
1058
1059
		{ mk_mii_read(MII_REG_CR), mii_parse_cr },
		{ mk_mii_read(MII_REG_ANAR), mii_parse_anar },
		{ mk_mii_end, }
1060
1061
	};
static phy_cmd_t const phy_cmd_ks8721bl_startup[] = {  /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
1062
1063
		{ mk_mii_write(MII_KS8721BL_ICSR, 0xff00), NULL },
		{ mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
1064
		{ mk_mii_read(MII_REG_SR), mii_parse_sr },
Linus Torvalds's avatar
Linus Torvalds committed
1065
		{ mk_mii_end, }
1066
1067
	};
static phy_cmd_t const phy_cmd_ks8721bl_ack_int[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1068
1069
1070
1071
1072
		/* 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, }
1073
1074
	};
static phy_cmd_t const phy_cmd_ks8721bl_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
1075
1076
		{ mk_mii_write(MII_KS8721BL_ICSR, 0x0000), NULL },
		{ mk_mii_end, }
1077
1078
	};
static phy_info_t const phy_info_ks8721bl = {
1079
	.id = 0x00022161,
1080
1081
1082
1083
1084
	.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
1085
1086
};

1087
1088
1089
1090
1091
1092
1093
/* ------------------------------------------------------------------------- */
/* 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)
{
1094
	struct fec_enet_private *fep = netdev_priv(dev);
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
	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
1146
1147
/* ------------------------------------------------------------------------- */

1148
static phy_info_t const * const phy_info[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1149
1150
1151
1152
1153
	&phy_info_lxt970,
	&phy_info_lxt971,
	&phy_info_qs6612,
	&phy_info_am79c874,
	&phy_info_ks8721bl,
1154
	&phy_info_dp83848,
Linus Torvalds's avatar
Linus Torvalds committed
1155
1156
1157
1158
	NULL
};

/* ------------------------------------------------------------------------- */
1159
#ifdef HAVE_mii_link_interrupt
Linus Torvalds's avatar
Linus Torvalds committed
1160
static irqreturn_t
1161
mii_link_interrupt(int irq, void * dev_id);
Linus Torvalds's avatar
Linus Torvalds committed
1162
1163

/*
1164
 *	This is specific to the MII interrupt setup of the M5272EVB.
Linus Torvalds's avatar
Linus Torvalds committed
1165
 */
1166
static void __inline__ fec_request_mii_intr(struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
1167
{
1168
1169
	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
1170
1171
1172
1173
1174
1175
}

static void __inline__ fec_disable_phy_intr(void)
{
	volatile unsigned long *icrp;
	icrp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_ICR1);
1176
	*icrp = 0x08000000;
Linus Torvalds's avatar
Linus Torvalds committed
1177
1178
1179
1180
1181
1182
1183
}

static void __inline__ fec_phy_ack_intr(void)
{
	volatile unsigned long *icrp;
	/* Acknowledge the interrupt */
	icrp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_ICR1);
1184
	*icrp = 0x0d000000;
Linus Torvalds's avatar
Linus Torvalds committed
1185
1186
}

1187
#ifdef CONFIG_M5272
1188
1189
1190
1191
1192