fec.c 67.3 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
10
/*
 * Fast Ethernet Controller (FEC) driver for Motorola MPC8xx.
 * Copyright (c) 1997 Dan Malek (dmalek@jlc.net)
 *
 * This version of the driver is specific to the FADS implementation,
 * since the board contains control registers external to the processor
 * for the control of the LevelOne LXT970 transceiver.  The MPC860T manual
 * describes connections using the internal parallel port I/O, which
 * is basically all of Port D.
 *
11
 * Right now, I am very wasteful with the buffers.  I allocate memory
Linus Torvalds's avatar
Linus Torvalds committed
12
13
14
15
16
17
18
19
20
 * 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.
 *
21
22
 * Support for FEC controller of ColdFire processors.
 * Copyright (c) 2001-2005 Greg Ungerer (gerg@snapgear.com)
23
24
 *
 * Bug fixes and cleanup by Philippe De Muyter (phdm@macqel.be)
25
 * Copyright (c) 2004-2006 Macq Electronique SA.
Linus Torvalds's avatar
Linus Torvalds committed
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 */

#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>

#include <asm/irq.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <asm/pgtable.h>
50
#include <asm/cacheflush.h>
Linus Torvalds's avatar
Linus Torvalds committed
51

52
#if defined(CONFIG_M523x) || defined(CONFIG_M527x) || \
53
    defined(CONFIG_M5272) || defined(CONFIG_M528x) || \
54
    defined(CONFIG_M520x) || defined(CONFIG_M532x)
Linus Torvalds's avatar
Linus Torvalds committed
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#include <asm/coldfire.h>
#include <asm/mcfsim.h>
#include "fec.h"
#else
#include <asm/8xx_immap.h>
#include <asm/mpc8xx.h>
#include "commproc.h"
#endif

#if defined(CONFIG_FEC2)
#define	FEC_MAX_PORTS	2
#else
#define	FEC_MAX_PORTS	1
#endif

/*
 * Define the fixed address of the FEC hardware.
 */
static unsigned int fec_hw[] = {
#if defined(CONFIG_M5272)
	(MCF_MBAR + 0x840),
#elif defined(CONFIG_M527x)
	(MCF_MBAR + 0x1000),
	(MCF_MBAR + 0x1800),
79
#elif defined(CONFIG_M523x) || defined(CONFIG_M528x)
Linus Torvalds's avatar
Linus Torvalds committed
80
	(MCF_MBAR + 0x1000),
81
82
#elif defined(CONFIG_M520x)
	(MCF_MBAR+0x30000),
83
84
#elif defined(CONFIG_M532x)
	(MCF_MBAR+0xfc030000),
Linus Torvalds's avatar
Linus Torvalds committed
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
#else
	&(((immap_t *)IMAP_ADDR)->im_cpm.cp_fec),
#endif
};

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
104
105
106
107
#elif defined (CONFIG_M5272C3)
#define	FEC_FLASHMAC	(0xffe04000 + 4)
#elif defined(CONFIG_MOD5272)
#define FEC_FLASHMAC 	0xffc0406b
Linus Torvalds's avatar
Linus Torvalds committed
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
#else
#define	FEC_FLASHMAC	0
#endif

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

145
#if (((RX_RING_SIZE + TX_RING_SIZE) * 8) > PAGE_SIZE)
146
#error "FEC: descriptor ring size constants too large"
147
148
#endif

Linus Torvalds's avatar
Linus Torvalds committed
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
/* 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


/*
170
 * The 5270/5271/5280/5282/532x RX control register also contains maximum frame
Linus Torvalds's avatar
Linus Torvalds committed
171
172
173
 * size bits. Other FEC hardware does not, so we need to take that into
 * account when setting it.
 */
174
#if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
175
    defined(CONFIG_M520x) || defined(CONFIG_M532x)
Linus Torvalds's avatar
Linus Torvalds committed
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
#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 */
	volatile fec_t	*hwp;

Greg Ungerer's avatar
Greg Ungerer committed
193
194
	struct net_device *netdev;

Linus Torvalds's avatar
Linus Torvalds committed
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
	/* 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.
	*/
	cbd_t	*rx_bd_base;		/* Address of Rx and Tx buffers. */
	cbd_t	*tx_bd_base;
	cbd_t	*cur_rx, *cur_tx;		/* The next free ring entry */
	cbd_t	*dirty_tx;	/* The ring entries to be free()ed. */
	uint	tx_full;
	spinlock_t lock;

	uint	phy_id;
	uint	phy_id_done;
	uint	phy_status;
	uint	phy_speed;
214
	phy_info_t const	*phy;
Linus Torvalds's avatar
Linus Torvalds committed
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
	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);
232
static irqreturn_t fec_enet_interrupt(int irq, void * dev_id);
Linus Torvalds's avatar
Linus Torvalds committed
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
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
253
254
255
256
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
257

258
static int	mii_queue(struct net_device *dev, int request,
Linus Torvalds's avatar
Linus Torvalds committed
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
				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            */
279
#define MII_REG_ANAR        4  /* A-N Advertisement Register               */
Linus Torvalds's avatar
Linus Torvalds committed
280
281
282
283
284
285
286
287
288
289
290
#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 */
291
#define PHY_CONF_10FDX	0x0020  /* 10 Mbit full duplex supported */
Linus Torvalds's avatar
Linus Torvalds committed
292
#define PHY_CONF_100HDX	0x0040  /* 100 Mbit half duplex supported */
293
#define PHY_CONF_100FDX	0x0080  /* 100 Mbit full duplex supported */
Linus Torvalds's avatar
Linus Torvalds committed
294
295
296
297
298
299

#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	*/
300
#define PHY_STAT_10FDX	0x2000  /* 10 Mbit full duplex selected	*/
Linus Torvalds's avatar
Linus Torvalds committed
301
#define PHY_STAT_100HDX	0x4000  /* 100 Mbit half duplex selected */
302
#define PHY_STAT_100FDX	0x8000  /* 100 Mbit full duplex selected */
Linus Torvalds's avatar
Linus Torvalds committed
303
304
305
306
307
308
309
310


static int
fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct fec_enet_private *fep;
	volatile fec_t	*fecp;
	volatile cbd_t	*bdp;
311
	unsigned short	status;
Linus Torvalds's avatar
Linus Torvalds committed
312
313
314
315
316
317
318
319
320
321
322
323

	fep = netdev_priv(dev);
	fecp = (volatile fec_t*)dev->base_addr;

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

	/* Fill in a Tx ring entry */
	bdp = fep->cur_tx;

324
	status = bdp->cbd_sc;
Linus Torvalds's avatar
Linus Torvalds committed
325
#ifndef final_version
326
	if (status & BD_ENET_TX_READY) {
Linus Torvalds's avatar
Linus Torvalds committed
327
328
329
330
331
332
333
334
335
336
		/* 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);
		return 1;
	}
#endif

	/* Clear all of the status flags.
	 */
337
	status &= ~BD_ENET_TX_STATS;
Linus Torvalds's avatar
Linus Torvalds committed
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359

	/* 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.
	 */
	if (bdp->cbd_bufaddr & 0x3) {
		unsigned int index;
		index = bdp - fep->tx_bd_base;
		memcpy(fep->tx_bounce[index], (void *) bdp->cbd_bufaddr, bdp->cbd_datlen);
		bdp->cbd_bufaddr = __pa(fep->tx_bounce[index]);
	}

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

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

Linus Torvalds's avatar
Linus Torvalds committed
363
364
365
366
367
368
369
370
	/* Push the data cache so the CPM does not get stale memory
	 * data.
	 */
	flush_dcache_range((unsigned long)skb->data,
			   (unsigned long)skb->data + skb->len);

	spin_lock_irq(&fep->lock);

371
372
	/* 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
373
374
	 */

375
	status |= (BD_ENET_TX_READY | BD_ENET_TX_INTR
Linus Torvalds's avatar
Linus Torvalds committed
376
			| BD_ENET_TX_LAST | BD_ENET_TX_TC);
377
	bdp->cbd_sc = status;
Linus Torvalds's avatar
Linus Torvalds committed
378
379
380
381

	dev->trans_start = jiffies;

	/* Trigger transmission start */
382
	fecp->fec_x_des_active = 0;
Linus Torvalds's avatar
Linus Torvalds committed
383
384
385

	/* If this was the last BD in the ring, start at the beginning again.
	*/
386
	if (status & BD_ENET_TX_WRAP) {
Linus Torvalds's avatar
Linus Torvalds committed
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
		bdp = fep->tx_bd_base;
	} else {
		bdp++;
	}

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

	fep->cur_tx = (cbd_t *)bdp;

	spin_unlock_irq(&fep->lock);

	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);
410
	dev->stats.tx_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
411
412
413
414
415
416
417
418
419
420
421
422
423
#ifndef final_version
	{
	int	i;
	cbd_t	*bdp;

	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++) {
424
		printk("  %08x: %04x %04x %08x\n",
Linus Torvalds's avatar
Linus Torvalds committed
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
		       (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
444
	fec_restart(dev, fep->full_duplex);
Linus Torvalds's avatar
Linus Torvalds committed
445
446
447
448
449
450
451
	netif_wake_queue(dev);
}

/* The interrupt handler.
 * This is called from the MPC core interrupt.
 */
static irqreturn_t
452
fec_enet_interrupt(int irq, void * dev_id)
Linus Torvalds's avatar
Linus Torvalds committed
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
{
	struct	net_device *dev = dev_id;
	volatile fec_t	*fecp;
	uint	int_events;
	int handled = 0;

	fecp = (volatile fec_t*)dev->base_addr;

	/* Get the interrupt events that caused us to be here.
	*/
	while ((int_events = fecp->fec_ievent) != 0) {
		fecp->fec_ievent = int_events;

		/* Handle receive event in its own function.
		 */
		if (int_events & FEC_ENET_RXF) {
			handled = 1;
			fec_enet_rx(dev);
		}

		/* Transmit OK, or non-fatal error. Update the buffer
		   descriptors. FEC handles all errors, we just discover
		   them as part of the transmit process.
		*/
		if (int_events & FEC_ENET_TXF) {
			handled = 1;
			fec_enet_tx(dev);
		}

		if (int_events & FEC_ENET_MII) {
			handled = 1;
			fec_enet_mii(dev);
		}
486

Linus Torvalds's avatar
Linus Torvalds committed
487
488
489
490
491
492
493
494
495
496
	}
	return IRQ_RETVAL(handled);
}


static void
fec_enet_tx(struct net_device *dev)
{
	struct	fec_enet_private *fep;
	volatile cbd_t	*bdp;
497
	unsigned short status;
Linus Torvalds's avatar
Linus Torvalds committed
498
499
500
501
502
503
	struct	sk_buff	*skb;

	fep = netdev_priv(dev);
	spin_lock(&fep->lock);
	bdp = fep->dirty_tx;

504
	while (((status = bdp->cbd_sc) & BD_ENET_TX_READY) == 0) {
Linus Torvalds's avatar
Linus Torvalds committed
505
506
507
508
		if (bdp == fep->cur_tx && fep->tx_full == 0) break;

		skb = fep->tx_skbuff[fep->skb_dirty];
		/* Check for errors. */
509
		if (status & (BD_ENET_TX_HB | BD_ENET_TX_LC |
Linus Torvalds's avatar
Linus Torvalds committed
510
511
				   BD_ENET_TX_RL | BD_ENET_TX_UN |
				   BD_ENET_TX_CSL)) {
512
			dev->stats.tx_errors++;
513
			if (status & BD_ENET_TX_HB)  /* No heartbeat */
514
				dev->stats.tx_heartbeat_errors++;
515
			if (status & BD_ENET_TX_LC)  /* Late collision */
516
				dev->stats.tx_window_errors++;
517
			if (status & BD_ENET_TX_RL)  /* Retrans limit */
518
				dev->stats.tx_aborted_errors++;
519
			if (status & BD_ENET_TX_UN)  /* Underrun */
520
				dev->stats.tx_fifo_errors++;
521
			if (status & BD_ENET_TX_CSL) /* Carrier lost */
522
				dev->stats.tx_carrier_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
523
		} else {
524
			dev->stats.tx_packets++;
Linus Torvalds's avatar
Linus Torvalds committed
525
526
527
		}

#ifndef final_version
528
		if (status & BD_ENET_TX_READY)
Linus Torvalds's avatar
Linus Torvalds committed
529
530
531
532
533
			printk("HEY! Enet xmit interrupt and TX_READY.\n");
#endif
		/* Deferred means some collisions occurred during transmit,
		 * but we eventually sent the packet OK.
		 */
534
		if (status & BD_ENET_TX_DEF)
535
			dev->stats.collisions++;
536

Linus Torvalds's avatar
Linus Torvalds committed
537
538
539
540
541
		/* 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;
542

Linus Torvalds's avatar
Linus Torvalds committed
543
544
		/* Update pointer to next buffer descriptor to be transmitted.
		 */
545
		if (status & BD_ENET_TX_WRAP)
Linus Torvalds's avatar
Linus Torvalds committed
546
547
548
			bdp = fep->tx_bd_base;
		else
			bdp++;
549

Linus Torvalds's avatar
Linus Torvalds committed
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
		/* 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);
		}
	}
	fep->dirty_tx = (cbd_t *)bdp;
	spin_unlock(&fep->lock);
}


/* 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)
{
	struct	fec_enet_private *fep;
	volatile fec_t	*fecp;
	volatile cbd_t *bdp;
575
	unsigned short status;
Linus Torvalds's avatar
Linus Torvalds committed
576
577
578
	struct	sk_buff	*skb;
	ushort	pkt_len;
	__u8 *data;
579

580
581
#ifdef CONFIG_M532x
	flush_cache_all();
582
#endif
Linus Torvalds's avatar
Linus Torvalds committed
583
584
585
586
587
588
589
590
591

	fep = netdev_priv(dev);
	fecp = (volatile fec_t*)dev->base_addr;

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

592
while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) {
Linus Torvalds's avatar
Linus Torvalds committed
593
594
595
596
597

#ifndef final_version
	/* Since we have allocated space to hold a complete frame,
	 * the last indicator should be set.
	 */
598
	if ((status & BD_ENET_RX_LAST) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
599
600
601
602
603
604
605
		printk("FEC ENET: rcv is not +last\n");
#endif

	if (!fep->opened)
		goto rx_processing_done;

	/* Check for errors. */
606
	if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
Linus Torvalds's avatar
Linus Torvalds committed
607
			   BD_ENET_RX_CR | BD_ENET_RX_OV)) {
608
		dev->stats.rx_errors++;
609
		if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH)) {
Linus Torvalds's avatar
Linus Torvalds committed
610
		/* Frame too long or too short. */
611
			dev->stats.rx_length_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
612
		}
613
		if (status & BD_ENET_RX_NO)	/* Frame alignment */
614
			dev->stats.rx_frame_errors++;
615
		if (status & BD_ENET_RX_CR)	/* CRC Error */
616
			dev->stats.rx_crc_errors++;
617
		if (status & BD_ENET_RX_OV)	/* FIFO overrun */
618
			dev->stats.rx_fifo_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
619
620
621
622
623
624
	}

	/* 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.
	 */
625
	if (status & BD_ENET_RX_CL) {
626
627
		dev->stats.rx_errors++;
		dev->stats.rx_frame_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
628
629
630
631
632
		goto rx_processing_done;
	}

	/* Process the incoming frame.
	 */
633
	dev->stats.rx_packets++;
Linus Torvalds's avatar
Linus Torvalds committed
634
	pkt_len = bdp->cbd_datlen;
635
	dev->stats.rx_bytes += pkt_len;
Linus Torvalds's avatar
Linus Torvalds committed
636
637
638
639
640
641
642
643
644
645
646
	data = (__u8*)__va(bdp->cbd_bufaddr);

	/* 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);
647
		dev->stats.rx_dropped++;
Linus Torvalds's avatar
Linus Torvalds committed
648
649
	} else {
		skb_put(skb,pkt_len-4);	/* Make room */
650
		skb_copy_to_linear_data(skb, data, pkt_len-4);
Linus Torvalds's avatar
Linus Torvalds committed
651
652
653
654
655
656
657
		skb->protocol=eth_type_trans(skb,dev);
		netif_rx(skb);
	}
  rx_processing_done:

	/* Clear the status flags for this buffer.
	*/
658
	status &= ~BD_ENET_RX_STATS;
Linus Torvalds's avatar
Linus Torvalds committed
659
660
661

	/* Mark the buffer empty.
	*/
662
663
	status |= BD_ENET_RX_EMPTY;
	bdp->cbd_sc = status;
Linus Torvalds's avatar
Linus Torvalds committed
664
665
666

	/* Update BD pointer to next entry.
	*/
667
	if (status & BD_ENET_RX_WRAP)
Linus Torvalds's avatar
Linus Torvalds committed
668
669
670
		bdp = fep->rx_bd_base;
	else
		bdp++;
671

Linus Torvalds's avatar
Linus Torvalds committed
672
673
674
675
676
#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.
	 */
677
	fecp->fec_r_des_active = 0;
Linus Torvalds's avatar
Linus Torvalds committed
678
#endif
679
   } /* while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) */
Linus Torvalds's avatar
Linus Torvalds committed
680
681
682
683
684
685
686
687
688
689
	fep->cur_rx = (cbd_t *)bdp;

#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.
	 */
690
	fecp->fec_r_des_active = 0;
Linus Torvalds's avatar
Linus Torvalds committed
691
692
693
694
#endif
}


695
/* called from interrupt context */
Linus Torvalds's avatar
Linus Torvalds committed
696
697
698
699
700
701
702
703
704
705
706
static void
fec_enet_mii(struct net_device *dev)
{
	struct	fec_enet_private *fep;
	volatile fec_t	*ep;
	mii_list_t	*mip;
	uint		mii_reg;

	fep = netdev_priv(dev);
	ep = fep->hwp;
	mii_reg = ep->fec_mii_data;
707
708

	spin_lock(&fep->lock);
709

Linus Torvalds's avatar
Linus Torvalds committed
710
711
	if ((mip = mii_head) == NULL) {
		printk("MII and no head!\n");
712
		goto unlock;
Linus Torvalds's avatar
Linus Torvalds committed
713
714
715
716
717
718
719
720
721
722
723
	}

	if (mip->mii_func != NULL)
		(*(mip->mii_func))(mii_reg, dev);

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

	if ((mip = mii_head) != NULL)
		ep->fec_mii_data = mip->mii_regval;
724
725
726

unlock:
	spin_unlock(&fep->lock);
Linus Torvalds's avatar
Linus Torvalds committed
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
}

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);
	regval |= fep->phy_addr << 23;

	retval = 0;

744
	spin_lock_irqsave(&fep->lock,flags);
Linus Torvalds's avatar
Linus Torvalds committed
745
746
747
748
749
750
751
752
753

	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;
754
		} else {
Linus Torvalds's avatar
Linus Torvalds committed
755
756
757
			mii_head = mii_tail = mip;
			fep->hwp->fec_mii_data = regval;
		}
758
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
759
760
761
		retval = 1;
	}

762
	spin_unlock_irqrestore(&fep->lock,flags);
Linus Torvalds's avatar
Linus Torvalds committed
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782

	return(retval);
}

static void mii_do_cmd(struct net_device *dev, const phy_cmd_t *c)
{
	int k;

	if(!c)
		return;

	for(k = 0; (c+k)->mii_data != mk_mii_end; k++) {
		mii_queue(dev, (c+k)->mii_data, (c+k)->funct);
	}
}

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

785
	status = *s & ~(PHY_STAT_LINK | PHY_STAT_FAULT | PHY_STAT_ANC);
Linus Torvalds's avatar
Linus Torvalds committed
786
787

	if (mii_reg & 0x0004)
788
		status |= PHY_STAT_LINK;
Linus Torvalds's avatar
Linus Torvalds committed
789
	if (mii_reg & 0x0010)
790
		status |= PHY_STAT_FAULT;
Linus Torvalds's avatar
Linus Torvalds committed
791
	if (mii_reg & 0x0020)
792
793
		status |= PHY_STAT_ANC;
	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
794
795
796
797
798
799
}

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

802
	status = *s & ~(PHY_CONF_ANE | PHY_CONF_LOOP);
Linus Torvalds's avatar
Linus Torvalds committed
803
804

	if (mii_reg & 0x1000)
805
		status |= PHY_CONF_ANE;
Linus Torvalds's avatar
Linus Torvalds committed
806
	if (mii_reg & 0x4000)
807
808
		status |= PHY_CONF_LOOP;
	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
809
810
811
812
813
814
}

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

817
	status = *s & ~(PHY_CONF_SPMASK);
Linus Torvalds's avatar
Linus Torvalds committed
818
819

	if (mii_reg & 0x0020)
820
		status |= PHY_CONF_10HDX;
Linus Torvalds's avatar
Linus Torvalds committed
821
	if (mii_reg & 0x0040)
822
		status |= PHY_CONF_10FDX;
Linus Torvalds's avatar
Linus Torvalds committed
823
	if (mii_reg & 0x0080)
824
		status |= PHY_CONF_100HDX;
Linus Torvalds's avatar
Linus Torvalds committed
825
	if (mii_reg & 0x00100)
826
827
		status |= PHY_CONF_100FDX;
	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
}

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

845
	status = *s & ~(PHY_STAT_SPMASK);
Linus Torvalds's avatar
Linus Torvalds committed
846
847
	if (mii_reg & 0x0800) {
		if (mii_reg & 0x1000)
848
			status |= PHY_STAT_100FDX;
Linus Torvalds's avatar
Linus Torvalds committed
849
		else
850
			status |= PHY_STAT_100HDX;
Linus Torvalds's avatar
Linus Torvalds committed
851
852
	} else {
		if (mii_reg & 0x1000)
853
			status |= PHY_STAT_10FDX;
Linus Torvalds's avatar
Linus Torvalds committed
854
		else
855
			status |= PHY_STAT_10HDX;
Linus Torvalds's avatar
Linus Torvalds committed
856
	}
857
	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
858
859
}

860
static phy_cmd_t const phy_cmd_lxt970_config[] = {
Linus Torvalds's avatar
Linus Torvalds committed
861
862
863
		{ mk_mii_read(MII_REG_CR), mii_parse_cr },
		{ mk_mii_read(MII_REG_ANAR), mii_parse_anar },
		{ mk_mii_end, }
864
865
	};
static phy_cmd_t const phy_cmd_lxt970_startup[] = { /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
866
867
868
		{ mk_mii_write(MII_LXT970_IER, 0x0002), NULL },
		{ mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
		{ mk_mii_end, }
869
870
	};
static phy_cmd_t const phy_cmd_lxt970_ack_int[] = {
Linus Torvalds's avatar
Linus Torvalds committed
871
872
873
874
875
876
877
		/* 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, }
878
879
	};
static phy_cmd_t const phy_cmd_lxt970_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
880
881
		{ mk_mii_write(MII_LXT970_IER, 0x0000), NULL },
		{ mk_mii_end, }
882
883
	};
static phy_info_t const phy_info_lxt970 = {
884
	.id = 0x07810000,
885
886
887
888
889
	.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
890
};
891

Linus Torvalds's avatar
Linus Torvalds committed
892
893
894
895
896
897
898
899
900
901
902
903
/* ------------------------------------------------------------------------- */
/* 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 */

904
/*
Linus Torvalds's avatar
Linus Torvalds committed
905
906
907
908
909
910
911
912
913
 * 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);
914
	uint status;
Linus Torvalds's avatar
Linus Torvalds committed
915

916
	status = *s & ~(PHY_STAT_SPMASK | PHY_STAT_LINK | PHY_STAT_ANC);
Linus Torvalds's avatar
Linus Torvalds committed
917
918
919

	if (mii_reg & 0x0400) {
		fep->link = 1;
920
		status |= PHY_STAT_LINK;
Linus Torvalds's avatar
Linus Torvalds committed
921
922
923
924
	} else {
		fep->link = 0;
	}
	if (mii_reg & 0x0080)
925
		status |= PHY_STAT_ANC;
Linus Torvalds's avatar
Linus Torvalds committed
926
927
	if (mii_reg & 0x4000) {
		if (mii_reg & 0x0200)
928
			status |= PHY_STAT_100FDX;
Linus Torvalds's avatar
Linus Torvalds committed
929
		else
930
			status |= PHY_STAT_100HDX;
Linus Torvalds's avatar
Linus Torvalds committed
931
932
	} else {
		if (mii_reg & 0x0200)
933
			status |= PHY_STAT_10FDX;
Linus Torvalds's avatar
Linus Torvalds committed
934
		else
935
			status |= PHY_STAT_10HDX;
Linus Torvalds's avatar
Linus Torvalds committed
936
937
	}
	if (mii_reg & 0x0008)
938
		status |= PHY_STAT_FAULT;
Linus Torvalds's avatar
Linus Torvalds committed
939

940
941
	*s = status;
}
942

943
static phy_cmd_t const phy_cmd_lxt971_config[] = {
944
		/* limit to 10MBit because my prototype board
Linus Torvalds's avatar
Linus Torvalds committed
945
946
947
948
949
		 * 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, }
950
951
	};
static phy_cmd_t const phy_cmd_lxt971_startup[] = {  /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
952
953
954
955
956
957
		{ 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 */
958
		{ mk_mii_read(MII_REG_SR), mii_parse_sr },
Linus Torvalds's avatar
Linus Torvalds committed
959
		{ mk_mii_end, }
960
961
962
963
	};
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
964
965
966
967
		/* 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, }
968
969
	};
static phy_cmd_t const phy_cmd_lxt971_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
970
971
		{ mk_mii_write(MII_LXT971_IER, 0x0000), NULL },
		{ mk_mii_end, }
972
973
	};
static phy_info_t const phy_info_lxt971 = {
974
	.id = 0x0001378e,
975
976
977
978
979
	.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
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
};

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

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

	switch((mii_reg >> 2) & 7) {
1003
1004
1005
1006
	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
1007
1008
}

1009
1010
1011
1012
	*s = status;
}

static phy_cmd_t const phy_cmd_qs6612_config[] = {
1013
		/* The PHY powers up isolated on the RPX,
Linus Torvalds's avatar
Linus Torvalds committed
1014
1015
1016
1017
1018
1019
1020
1021
		 * 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, }
1022
1023
	};
static phy_cmd_t const phy_cmd_qs6612_startup[] = {  /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
1024
1025
1026
		{ mk_mii_write(MII_QS6612_IMR, 0x003a), NULL },
		{ mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
		{ mk_mii_end, }
1027
1028
	};
static phy_cmd_t const phy_cmd_qs6612_ack_int[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1029
1030
1031
1032
1033
1034
1035
1036
		/* 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, }
1037
1038
	};
static phy_cmd_t const phy_cmd_qs6612_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
1039
1040
		{ mk_mii_write(MII_QS6612_IMR, 0x0000), NULL },
		{ mk_mii_end, }
1041
1042
	};
static phy_info_t const phy_info_qs6612 = {
1043
	.id = 0x00181440,
1044
1045
1046
1047
1048
	.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
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
};

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

1070
	status = *s & ~(PHY_STAT_SPMASK | PHY_STAT_ANC);
Linus Torvalds's avatar
Linus Torvalds committed
1071
1072

	if (mii_reg & 0x0080)
1073
		status |= PHY_STAT_ANC;
Linus Torvalds's avatar
Linus Torvalds committed
1074
	if (mii_reg & 0x0400)
1075
		status |= ((mii_reg & 0x0800) ? PHY_STAT_100FDX : PHY_STAT_100HDX);
Linus Torvalds's avatar
Linus Torvalds committed
1076
	else
1077
1078
1079
		status |= ((mii_reg & 0x0800) ? PHY_STAT_10FDX : PHY_STAT_10HDX);

	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
1080
1081
}

1082
static phy_cmd_t const phy_cmd_am79c874_config[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1083
1084
1085
1086
		{ 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, }
1087
1088
	};
static phy_cmd_t const phy_cmd_am79c874_startup[] = {  /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
1089
1090
		{ mk_mii_write(MII_AM79C874_ICSR, 0xff00), NULL },
		{ mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
1091
		{ mk_mii_read(MII_REG_SR), mii_parse_sr },
Linus Torvalds's avatar
Linus Torvalds committed
1092
		{ mk_mii_end, }
1093
1094
	};
static phy_cmd_t const phy_cmd_am79c874_ack_int[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1095
1096
1097
1098
1099
1100
		/* 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, }
1101
1102
	};
static phy_cmd_t const phy_cmd_am79c874_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
1103
1104
		{ mk_mii_write(MII_AM79C874_ICSR, 0x0000), NULL },
		{ mk_mii_end, }
1105
1106
1107
1108
1109
1110
1111
1112
	};
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
1113
1114
};

1115

Linus Torvalds's avatar
Linus Torvalds committed
1116
1117
1118
1119
1120
1121
1122
1123
1124
/* ------------------------------------------------------------------------- */
/* Kendin KS8721BL phy                                                       */

/* register definitions for the 8721 */

#define MII_KS8721BL_RXERCR	21
#define MII_KS8721BL_ICSR	22
#define	MII_KS8721BL_PHYCR	31

1125
static phy_cmd_t const phy_cmd_ks8721bl_config[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1126
1127
1128
		{ mk_mii_read(MII_REG_CR), mii_parse_cr },
		{ mk_mii_read(MII_REG_ANAR), mii_parse_anar },
		{ mk_mii_end, }
1129
1130
	};
static phy_cmd_t const phy_cmd_ks8721bl_startup[] = {  /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
1131
1132
		{ mk_mii_write(MII_KS8721BL_ICSR, 0xff00), NULL },
		{ mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
1133
		{ mk_mii_read(MII_REG_SR), mii_parse_sr },
Linus Torvalds's avatar
Linus Torvalds committed
1134
		{ mk_mii_end, }
1135
1136
	};
static phy_cmd_t const phy_cmd_ks8721bl_ack_int[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1137
1138
1139
1140
1141
		/* 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, }
1142
1143
	};
static phy_cmd_t const phy_cmd_ks8721bl_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
1144
1145
		{ mk_mii_write(MII_KS8721BL_ICSR, 0x0000), NULL },
		{ mk_mii_end, }
1146
1147
	};
static phy_info_t const phy_info_ks8721bl = {
1148
	.id = 0x00022161,
1149
1150
1151
1152
1153
	.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
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
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
/* ------------------------------------------------------------------------- */
/* 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)
{
	struct fec_enet_private *fep = dev->priv;
	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
1215
1216
/* ------------------------------------------------------------------------- */

1217
static phy_info_t const * const phy_info[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1218
1219
1220
1221
1222
	&phy_info_lxt970,
	&phy_info_lxt971,
	&phy_info_qs6612,
	&phy_info_am79c874,
	&phy_info_ks8721bl,
1223
	&phy_info_dp83848,
Linus Torvalds's avatar
Linus Torvalds committed
1224
1225
1226
1227
	NULL
};

/* ------------------------------------------------------------------------- */
1228
#if !defined(CONFIG_M532x)
Linus Torvalds's avatar
Linus Torvalds committed
1229
1230
1231
1232
1233
#ifdef CONFIG_RPXCLASSIC
static void
mii_link_interrupt(void *dev_id);
#else
static irqreturn_t
1234
mii_link_interrupt(int irq, void * dev_id);
Linus Torvalds's avatar
Linus Torvalds committed
1235
#endif
1236
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1237
1238
1239
1240
1241
1242
1243
1244

#if defined(CONFIG_M5272)
/*
 *	Code specific to Coldfire 5272 setup.
 */
static void __inline__ fec_request_intrs(struct net_device *dev)
{
	volatile unsigned long *icrp;
1245
1246
1247
	static const struct idesc {
		char *name;
		unsigned short irq;
1248
		irq_handler_t handler;
1249
1250
1251
1252
1253
1254
1255
	} *idp, id[] = {
		{ "fec(RX)", 86, fec_enet_interrupt },
		{ "fec(TX)", 87, fec_enet_interrupt },
		{ "fec(OTHER)", 88, fec_enet_interrupt },
		{ "fec(MII)", 66, mii_link_interrupt },
		{ NULL },
	};
Linus Torvalds's avatar
Linus Torvalds committed
1256
1257

	/* Setup interrupt handlers. */
1258
1259
1260
1261
	for (idp = id; idp->name; idp++) {
		if (request_irq(idp->irq, idp->handler, 0, idp->name, dev) != 0)
			printk("FEC: Could not allocate %s IRQ(%d)!\n", idp->name, idp->irq);
	}
Linus Torvalds's avatar
Linus Torvalds committed
1262
1263
1264
1265
1266

	/* Unmask interrupt at ColdFire 5272 SIM */
	icrp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_ICR3);
	*icrp = 0x00000ddd;
	icrp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_ICR1);
1267
	*icrp = 0x0d000000;
Linus Torvalds's avatar
Linus Torvalds committed
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
}

static void __inline__ fec_set_mii(struct net_device *dev, struct fec_enet_private *fep)
{
	volatile fec_t *fecp;

	fecp = fep->hwp;
	fecp->fec_r_cntrl = OPT_FRAME_SIZE | 0x04;
	fecp->fec_x_cntrl = 0x00;

	/*
	 * Set MII speed to 2.5 MHz
	 * See 5272 manual section 11.5.8: MSCR
	 */
	fep->phy_speed = ((((MCF_CLK / 4) / (2500000 / 10)) + 5) / 10) * 2;
	fecp->fec_mii_speed = fep->phy_speed;

	fec_restart(dev, 0);
}

static void __inline__ fec_get_mac(struct net_device *dev)
{
	struct fec_enet_private *fep = netdev_priv(dev);
	volatile fec_t *fecp;
1292
	unsigned char *iap, tmpaddr[ETH_ALEN];
Linus Torvalds's avatar
Linus Torvalds committed
1293
1294
1295

	fecp = fep->hwp;

1296
	if (FEC_FLASHMAC) {
Linus Torvalds's avatar
Linus Torvalds committed
1297
1298
1299
1300
		/*
		 * Get MAC address from FLASH.
		 * If it is all 1's or 0's, use the default.
		 */
1301
		iap = (unsigned char *)FEC_FLASHMAC;
Linus Torvalds's avatar
Linus Torvalds committed
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
		if ((iap[0] == 0) && (iap[1] == 0) && (iap[2] == 0) &&
		    (iap[3] == 0) && (iap[4] == 0) && (iap[5] == 0))
			iap = fec_mac_default;
		if ((iap[0] == 0xff) && (iap[1] == 0xff) && (iap[2] == 0xff) &&
		    (iap[3] == 0xff) && (iap[4] == 0xff) && (iap[5] == 0xff))
			iap = fec_mac_default;
	} else {
		*((unsigned long *) &tmpaddr[0]) = fecp->fec_addr_low;
		*((unsigned short *) &tmpaddr[4]) = (fecp->fec_addr_high >> 16);
		iap = &tmpaddr[0];
	}

1314
	memcpy(dev->dev_addr, iap, ETH_ALEN);
Linus Torvalds's avatar
Linus Torvalds committed
1315
1316

	/* Adjust MAC if using default MAC address */
1317
1318
	if (iap == fec_mac_default)
		 dev->dev_addr[ETH_ALEN-1] = fec_mac_default[ETH_ALEN-1] + fep->index;
Linus Torvalds's avatar
Linus Torvalds committed
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
}

static void __inline__ fec_enable_phy_intr(void)
{
}

static void __inline__ fec_disable_phy_intr(void)
{
	volatile unsigned long *icrp;
	icrp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_ICR1);
1329
	*icrp = 0x08000000;
Linus Torvalds's avatar
Linus Torvalds committed
1330
1331
1332
1333
1334
1335
1336
}

static void __inline__ fec_phy_ack_intr(void)
{
	volatile unsigned long *icrp;
	/* Acknowledge the interrupt */
	icrp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_ICR1);
1337
	*icrp = 0x0d000000;
Linus Torvalds's avatar
Linus Torvalds committed
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
}

static void __inline__ fec_localhw_setup(void)
{
}

/*
 *	Do not need to make region uncached on 5272.
 */
static void __inline__ fec_uncache(unsigned long addr)
{
}

/* ------------------------------------------------------------------------- */

1353
#elif defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x)
Linus Torvalds's avatar
Linus Torvalds committed
1354
1355

/*
1356
1357
 *	Code specific to Coldfire 5230/5231/5232/5234/5235,
 *	the 5270/5271/5274/5275 and 5280/5282 setups.
Linus Torvalds's avatar
Linus Torvalds committed
1358
1359
1360
1361
1362
 */
static void __inline__ fec_request_intrs(struct net_device *dev)
{
	struct fec_enet_private *fep;
	int b;
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
	static const struct idesc {
		char *name;
		unsigned short irq;
	} *idp, id[] = {
		{ "fec(TXF)", 23 },
		{ "fec(TXB)", 24 },
		{ "fec(TXFIFO)", 25 },
		{ "fec(TXCR)", 26 },
		{ "fec(RXF)", 27 },
		{ "fec(RXB)", 28 },
		{ "fec(MII)", 29 },
		{ "fec(LC)", 30 },
		{ "fec(HBERR)", 31 },
		{ "fec(GRA)", 32 },
		{ "fec(EBERR)", 33 },
		{ "fec(BABT)", 34 },
		{ "fec(BABR)", 35 },
		{ NULL },
	};
Linus Torvalds's avatar
Linus Torvalds committed
1382
1383
1384
1385
1386

	fep = netdev_priv(dev);
	b = (fep->index) ? 128 : 64;

	/* Setup interrupt handlers. */
1387
1388
1389
1390
	for (idp = id; idp->name; idp++) {
		if (request_irq(b+idp->irq, fec_enet_interrupt, 0, idp->name, dev) != 0)
			printk("FEC: Could not allocate %s IRQ(%d)!\n", idp->name, b+idp->irq);
	}
Linus Torvalds's avatar
Linus Torvalds committed
1391
1392
1393
1394
1395

	/* Unmask interrupts at ColdFire 5280/5282 interrupt controller */
	{
		volatile unsigned char  *icrp;
		volatile unsigned long  *imrp;
1396
		int i, ilip;
Linus Torvalds's avatar
Linus Torvalds committed
1397
1398
1399
1400

		b = (fep->index) ? MCFICM_INTC1 : MCFICM_INTC0;
		icrp = (volatile unsigned char *) (MCF_IPSBAR + b +
			MCFINTC_ICR0);
1401
1402
		for (i = 23, ilip = 0x28; (i < 36); i++)
			icrp[i] = ilip--;
Linus Torvalds's avatar
Linus Torvalds committed
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414

		imrp = (volatile unsigned long *) (MCF_IPSBAR + b +
			MCFINTC_IMRH);
		*imrp &= ~0x0000000f;
		imrp = (volatile unsigned long *) (MCF_IPSBAR + b +
			MCFINTC_IMRL);
		*imrp &= ~0xff800001;
	}

#if defined(CONFIG_M528x)
	/* Set up gpio outputs for MII lines */
	{
1415
1416
		volatile u16 *gpio_paspar;
		volatile u8 *gpio_pehlpar;
1417

1418
1419
1420
1421
		gpio_paspar = (volatile u16 *) (MCF_IPSBAR + 0x100056);
		gpio_pehlpar = (volatile u16 *) (MCF_IPSBAR + 0x100058);
		*gpio_paspar |= 0x0f00;
		*gpio_pehlpar = 0xc0;
Linus Torvalds's avatar
Linus Torvalds committed
1422
1423