Skip to content
fec.c 53.5 KiB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
/*
 * Fast Ethernet Controller (FEC) driver for Motorola MPC8xx.
 * Copyright (c) 1997 Dan Malek (dmalek@jlc.net)
 *
 * Right now, I am very wasteful with the buffers.  I allocate memory
Linus Torvalds's avatar
Linus Torvalds committed
 * 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.
 *
 * Support for FEC controller of ColdFire processors.
 * Copyright (c) 2001-2005 Greg Ungerer (gerg@snapgear.com)
 *
 * Bug fixes and cleanup by Philippe De Muyter (phdm@macqel.be)
 * Copyright (c) 2004-2006 Macq Electronique SA.
Linus Torvalds's avatar
Linus Torvalds committed
 */

#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 <linux/io.h>
#include <linux/irq.h>
#include <linux/clk.h>
#include <linux/platform_device.h>
Linus Torvalds's avatar
Linus Torvalds committed

#include <asm/cacheflush.h>

#ifndef CONFIG_ARCH_MXC
Linus Torvalds's avatar
Linus Torvalds committed
#include <asm/coldfire.h>
#include <asm/mcfsim.h>
Linus Torvalds's avatar
Linus Torvalds committed
#include "fec.h"

#ifdef CONFIG_ARCH_MXC
#include <mach/hardware.h>
#define FEC_ALIGNMENT	0xf
#else
#define FEC_ALIGNMENT	0x3
#endif

/*
 * Define the fixed address of the FEC hardware.
 */
#define HAVE_mii_link_interrupt
Linus Torvalds's avatar
Linus Torvalds committed

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
#elif defined (CONFIG_M5272C3)
#define	FEC_FLASHMAC	(0xffe04000 + 4)
#elif defined(CONFIG_MOD5272)
#define FEC_FLASHMAC 	0xffc0406b
Linus Torvalds's avatar
Linus Torvalds committed
#else
#define	FEC_FLASHMAC	0
#endif
Sascha Hauer's avatar
Sascha Hauer committed
/* Forward declarations of some structures to support different PHYs */
Linus Torvalds's avatar
Linus Torvalds committed

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

#if (((RX_RING_SIZE + TX_RING_SIZE) * 8) > PAGE_SIZE)
#error "FEC: descriptor ring size constants too large"
Sascha Hauer's avatar
Sascha Hauer committed
/* Interrupt events/masks. */
Linus Torvalds's avatar
Linus Torvalds committed
#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


/*
 * The 5270/5271/5280/5282/532x RX control register also contains maximum frame
Linus Torvalds's avatar
Linus Torvalds committed
 * size bits. Other FEC hardware does not, so we need to take that into
 * account when setting it.
 */
#if defined(CONFIG_M523x) || defined(CONFIG_M527x) || defined(CONFIG_M528x) || \
    defined(CONFIG_M520x) || defined(CONFIG_M532x) || defined(CONFIG_ARCH_MXC)
Linus Torvalds's avatar
Linus Torvalds committed
#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 */
	void __iomem *hwp;
Linus Torvalds's avatar
Linus Torvalds committed

	struct net_device *netdev;

Linus Torvalds's avatar
Linus Torvalds committed
	/* 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
	/* CPM dual port RAM relative addresses */
	dma_addr_t	bd_dma;
Sascha Hauer's avatar
Sascha Hauer committed
	/* Address of Rx and Tx buffers */
	struct bufdesc	*rx_bd_base;
	struct bufdesc	*tx_bd_base;
	/* The next free ring entry */
	struct bufdesc	*cur_rx, *cur_tx; 
Sascha Hauer's avatar
Sascha Hauer committed
	/* The ring entries to be free()ed */
	struct bufdesc	*dirty_tx;

Linus Torvalds's avatar
Linus Torvalds committed
	uint	tx_full;
	/* 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

	uint	phy_id;
	uint	phy_id_done;
	uint	phy_status;
	uint	phy_speed;
Linus Torvalds's avatar
Linus Torvalds committed
	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);
static irqreturn_t fec_enet_interrupt(int irq, void * dev_id);
Linus Torvalds's avatar
Linus Torvalds committed
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
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

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

Sascha Hauer's avatar
Sascha Hauer committed
/* Make MII read/write commands for the FEC */
Linus Torvalds's avatar
Linus Torvalds committed
#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
/* Transmitter timeout */
#define TX_TIMEOUT (2 * HZ)
Linus Torvalds's avatar
Linus Torvalds committed

Sascha Hauer's avatar
Sascha Hauer committed
/* Register definitions for the PHY */
Linus Torvalds's avatar
Linus Torvalds committed

#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            */
#define MII_REG_ANAR        4  /* A-N Advertisement Register               */
Linus Torvalds's avatar
Linus Torvalds committed
#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 */
#define PHY_CONF_10FDX	0x0020  /* 10 Mbit full duplex supported */
Linus Torvalds's avatar
Linus Torvalds committed
#define PHY_CONF_100HDX	0x0040  /* 100 Mbit half duplex supported */
#define PHY_CONF_100FDX	0x0080  /* 100 Mbit full duplex supported */
Linus Torvalds's avatar
Linus Torvalds committed

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


static int
fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct fec_enet_private *fep = netdev_priv(dev);
	struct bufdesc *bdp;
	unsigned short	status;
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed

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

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

	status = bdp->cbd_sc;
	if (status & BD_ENET_TX_READY) {
Linus Torvalds's avatar
Linus Torvalds committed
		/* 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);
		spin_unlock_irqrestore(&fep->hw_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
		return 1;
	}

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

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

	/*
Sascha Hauer's avatar
Sascha Hauer committed
	 * 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
	 */
	if (bdp->cbd_bufaddr & FEC_ALIGNMENT) {
Linus Torvalds's avatar
Linus Torvalds committed
		unsigned int index;
		index = bdp - fep->tx_bd_base;
		memcpy(fep->tx_bounce[index], (void *)skb->data, skb->len);
Linus Torvalds's avatar
Linus Torvalds committed
		bdp->cbd_bufaddr = __pa(fep->tx_bounce[index]);
	}

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

Linus Torvalds's avatar
Linus Torvalds committed
	fep->skb_cur = (fep->skb_cur+1) & TX_RING_MOD_MASK;
Linus Torvalds's avatar
Linus Torvalds committed
	/* Push the data cache so the CPM does not get stale memory
	 * data.
	 */
	dma_sync_single(NULL, bdp->cbd_bufaddr,
			bdp->cbd_datlen, DMA_TO_DEVICE);
Linus Torvalds's avatar
Linus Torvalds committed

	/* 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
	 */
	status |= (BD_ENET_TX_READY | BD_ENET_TX_INTR
Linus Torvalds's avatar
Linus Torvalds committed
			| BD_ENET_TX_LAST | BD_ENET_TX_TC);
	bdp->cbd_sc = status;
Linus Torvalds's avatar
Linus Torvalds committed

	dev->trans_start = jiffies;

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

Sascha Hauer's avatar
Sascha Hauer committed
	/* 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
		bdp = fep->tx_bd_base;
Sascha Hauer's avatar
Sascha Hauer committed
	else
Linus Torvalds's avatar
Linus Torvalds committed
		bdp++;

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

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

	spin_unlock_irqrestore(&fep->hw_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed

	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);
Linus Torvalds's avatar
Linus Torvalds committed
#ifndef final_version
	{
	int	i;
	struct bufdesc *bdp;
Linus Torvalds's avatar
Linus Torvalds committed

	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++) {
		printk("  %08x: %04x %04x %08x\n",
Linus Torvalds's avatar
Linus Torvalds committed
		       (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
	fec_restart(dev, fep->full_duplex);
Linus Torvalds's avatar
Linus Torvalds committed
	netif_wake_queue(dev);
}

static irqreturn_t
fec_enet_interrupt(int irq, void * dev_id)
Linus Torvalds's avatar
Linus Torvalds committed
{
	struct	net_device *dev = dev_id;
	struct fec_enet_private *fep = netdev_priv(dev);
Linus Torvalds's avatar
Linus Torvalds committed
	uint	int_events;
	irqreturn_t ret = IRQ_NONE;
Linus Torvalds's avatar
Linus Torvalds committed

		int_events = readl(fep->hwp + FEC_IEVENT);
		writel(int_events, fep->hwp + FEC_IEVENT);
Linus Torvalds's avatar
Linus Torvalds committed

		if (int_events & FEC_ENET_RXF) {
			ret = IRQ_HANDLED;
Linus Torvalds's avatar
Linus Torvalds committed
			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.
		 */
Linus Torvalds's avatar
Linus Torvalds committed
		if (int_events & FEC_ENET_TXF) {
			ret = IRQ_HANDLED;
Linus Torvalds's avatar
Linus Torvalds committed
			fec_enet_tx(dev);
		}

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

	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
}


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

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

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

		skb = fep->tx_skbuff[fep->skb_dirty];
		/* Check for errors. */
		if (status & (BD_ENET_TX_HB | BD_ENET_TX_LC |
Linus Torvalds's avatar
Linus Torvalds committed
				   BD_ENET_TX_RL | BD_ENET_TX_UN |
				   BD_ENET_TX_CSL)) {
			if (status & BD_ENET_TX_HB)  /* No heartbeat */
				dev->stats.tx_heartbeat_errors++;
			if (status & BD_ENET_TX_LC)  /* Late collision */
			if (status & BD_ENET_TX_RL)  /* Retrans limit */
			if (status & BD_ENET_TX_UN)  /* Underrun */
			if (status & BD_ENET_TX_CSL) /* Carrier lost */
Linus Torvalds's avatar
Linus Torvalds committed
		} else {
		if (status & BD_ENET_TX_READY)
Linus Torvalds's avatar
Linus Torvalds committed
			printk("HEY! Enet xmit interrupt and TX_READY.\n");
Linus Torvalds's avatar
Linus Torvalds committed
		/* Deferred means some collisions occurred during transmit,
		 * but we eventually sent the packet OK.
		 */
		if (status & BD_ENET_TX_DEF)
Sascha Hauer's avatar
Sascha Hauer committed
		/* Free the sk buffer associated with this last transmit */
Linus Torvalds's avatar
Linus Torvalds committed
		dev_kfree_skb_any(skb);
		fep->tx_skbuff[fep->skb_dirty] = NULL;
		fep->skb_dirty = (fep->skb_dirty + 1) & TX_RING_MOD_MASK;
Sascha Hauer's avatar
Sascha Hauer committed
		/* Update pointer to next buffer descriptor to be transmitted */
		if (status & BD_ENET_TX_WRAP)
Linus Torvalds's avatar
Linus Torvalds committed
			bdp = fep->tx_bd_base;
		else
			bdp++;
Sascha Hauer's avatar
Sascha Hauer committed
		/* Since we have freed up a buffer, the ring is no longer full
Linus Torvalds's avatar
Linus Torvalds committed
		 */
		if (fep->tx_full) {
			fep->tx_full = 0;
			if (netif_queue_stopped(dev))
				netif_wake_queue(dev);
		}
	}
	fep->dirty_tx = bdp;
	spin_unlock_irq(&fep->hw_lock);
Linus Torvalds's avatar
Linus Torvalds committed
}


/* 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 = netdev_priv(dev);
	struct bufdesc *bdp;
	unsigned short status;
Linus Torvalds's avatar
Linus Torvalds committed
	struct	sk_buff	*skb;
	ushort	pkt_len;
	__u8 *data;
#ifdef CONFIG_M532x
	flush_cache_all();
Linus Torvalds's avatar
Linus Torvalds committed

	spin_lock_irq(&fep->hw_lock);

Linus Torvalds's avatar
Linus Torvalds committed
	/* 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
	while (!((status = bdp->cbd_sc) & BD_ENET_RX_EMPTY)) {
Linus Torvalds's avatar
Linus Torvalds committed

Sascha Hauer's avatar
Sascha Hauer committed
		/* 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

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

Sascha Hauer's avatar
Sascha Hauer committed
		/* Check for errors. */
		if (status & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_NO |
Linus Torvalds's avatar
Linus Torvalds committed
			   BD_ENET_RX_CR | BD_ENET_RX_OV)) {
Sascha Hauer's avatar
Sascha Hauer committed
			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++;
Sascha Hauer's avatar
Sascha Hauer committed
		/* 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

Sascha Hauer's avatar
Sascha Hauer committed
		/* 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

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

Sascha Hauer's avatar
Sascha Hauer committed
		/* 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

Sascha Hauer's avatar
Sascha Hauer committed
		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

Sascha Hauer's avatar
Sascha Hauer committed
		/* Mark the buffer empty */
		status |= BD_ENET_RX_EMPTY;
		bdp->cbd_sc = status;
Sascha Hauer's avatar
Sascha Hauer committed
		/* 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);
	}
	fep->cur_rx = bdp;
Linus Torvalds's avatar
Linus Torvalds committed

	spin_unlock_irq(&fep->hw_lock);
/* called from interrupt context */
Linus Torvalds's avatar
Linus Torvalds committed
static void
fec_enet_mii(struct net_device *dev)
{
	struct	fec_enet_private *fep;
	mii_list_t	*mip;

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

Linus Torvalds's avatar
Linus Torvalds committed
	if ((mip = mii_head) == NULL) {
		printk("MII and no head!\n");
Linus Torvalds's avatar
Linus Torvalds committed
	}

	if (mip->mii_func != NULL)
		(*(mip->mii_func))(readl(fep->hwp + FEC_MII_DATA), dev);
Linus Torvalds's avatar
Linus Torvalds committed

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

	if ((mip = mii_head) != NULL)
		writel(mip->mii_regval, fep->hwp + FEC_MII_DATA);
	spin_unlock_irq(&fep->mii_lock);
Linus Torvalds's avatar
Linus Torvalds committed
}

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
	/* Add PHY address to register command */
Linus Torvalds's avatar
Linus Torvalds committed
	fep = netdev_priv(dev);
	spin_lock_irqsave(&fep->mii_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed

	regval |= fep->phy_addr << 23;
Linus Torvalds's avatar
Linus Torvalds committed
	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;
Linus Torvalds's avatar
Linus Torvalds committed
			mii_head = mii_tail = mip;
			writel(regval, fep->hwp + FEC_MII_DATA);
Linus Torvalds's avatar
Linus Torvalds committed
		}
Linus Torvalds's avatar
Linus Torvalds committed
		retval = 1;
	}

	spin_unlock_irqrestore(&fep->mii_lock, flags);
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
}

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

	for (; c->mii_data != mk_mii_end; c++)
		mii_queue(dev, c->mii_data, c->funct);
Linus Torvalds's avatar
Linus Torvalds committed
}

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

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

	if (mii_reg & 0x0004)
		status |= PHY_STAT_LINK;
Linus Torvalds's avatar
Linus Torvalds committed
	if (mii_reg & 0x0010)
		status |= PHY_STAT_FAULT;
Linus Torvalds's avatar
Linus Torvalds committed
	if (mii_reg & 0x0020)
		status |= PHY_STAT_ANC;
	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
}

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

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

	if (mii_reg & 0x1000)
		status |= PHY_CONF_ANE;
Linus Torvalds's avatar
Linus Torvalds committed
	if (mii_reg & 0x4000)
		status |= PHY_CONF_LOOP;
	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
}

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

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

	if (mii_reg & 0x0020)
		status |= PHY_CONF_10HDX;
Linus Torvalds's avatar
Linus Torvalds committed
	if (mii_reg & 0x0040)
		status |= PHY_CONF_10FDX;
Linus Torvalds's avatar
Linus Torvalds committed
	if (mii_reg & 0x0080)
		status |= PHY_CONF_100HDX;
Linus Torvalds's avatar
Linus Torvalds committed
	if (mii_reg & 0x00100)
		status |= PHY_CONF_100FDX;
	*s = status;
Linus Torvalds's avatar
Linus Torvalds committed
}

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

	status = *s & ~(PHY_STAT_SPMASK);
Linus Torvalds's avatar
Linus Torvalds committed
	if (mii_reg & 0x0800) {
		if (mii_reg & 0x1000)
			status |= PHY_STAT_100FDX;
Linus Torvalds's avatar
Linus Torvalds committed
		else
			status |= PHY_STAT_100HDX;
Linus Torvalds's avatar
Linus Torvalds committed
	} else {
		if (mii_reg & 0x1000)
			status |= PHY_STAT_10FDX;
Linus Torvalds's avatar
Linus Torvalds committed
		else
			status |= PHY_STAT_10HDX;
Linus Torvalds's avatar
Linus Torvalds committed
	}
static phy_cmd_t const phy_cmd_lxt970_config[] = {
Linus Torvalds's avatar
Linus Torvalds committed
		{ mk_mii_read(MII_REG_CR), mii_parse_cr },
		{ mk_mii_read(MII_REG_ANAR), mii_parse_anar },
		{ mk_mii_end, }
	};
static phy_cmd_t const phy_cmd_lxt970_startup[] = { /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
		{ mk_mii_write(MII_LXT970_IER, 0x0002), NULL },
		{ mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
		{ mk_mii_end, }
	};
static phy_cmd_t const phy_cmd_lxt970_ack_int[] = {
Linus Torvalds's avatar
Linus Torvalds committed
		/* 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, }
	};
static phy_cmd_t const phy_cmd_lxt970_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
		{ mk_mii_write(MII_LXT970_IER, 0x0000), NULL },
		{ mk_mii_end, }
	};
static phy_info_t const phy_info_lxt970 = {
	.id = 0x07810000,
	.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
};
Linus Torvalds's avatar
Linus Torvalds committed
/* ------------------------------------------------------------------------- */
/* 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 */

Linus Torvalds's avatar
Linus Torvalds committed
 * 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);
Linus Torvalds's avatar
Linus Torvalds committed

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

	if (mii_reg & 0x0400) {
		fep->link = 1;
		status |= PHY_STAT_LINK;
Linus Torvalds's avatar
Linus Torvalds committed
	} else {
		fep->link = 0;
	}
	if (mii_reg & 0x0080)
		status |= PHY_STAT_ANC;
Linus Torvalds's avatar
Linus Torvalds committed
	if (mii_reg & 0x4000) {
		if (mii_reg & 0x0200)
			status |= PHY_STAT_100FDX;
Linus Torvalds's avatar
Linus Torvalds committed
		else
			status |= PHY_STAT_100HDX;
Linus Torvalds's avatar
Linus Torvalds committed
	} else {
		if (mii_reg & 0x0200)
			status |= PHY_STAT_10FDX;
Linus Torvalds's avatar
Linus Torvalds committed
		else
			status |= PHY_STAT_10HDX;
Linus Torvalds's avatar
Linus Torvalds committed
	}
	if (mii_reg & 0x0008)
		status |= PHY_STAT_FAULT;
Linus Torvalds's avatar
Linus Torvalds committed

static phy_cmd_t const phy_cmd_lxt971_config[] = {
		/* limit to 10MBit because my prototype board
Linus Torvalds's avatar
Linus Torvalds committed
		 * 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, }
	};
static phy_cmd_t const phy_cmd_lxt971_startup[] = {  /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
		{ 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 */
		{ mk_mii_read(MII_REG_SR), mii_parse_sr },
Linus Torvalds's avatar
Linus Torvalds committed
		{ mk_mii_end, }
	};
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
		/* 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, }
	};
static phy_cmd_t const phy_cmd_lxt971_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
		{ mk_mii_write(MII_LXT971_IER, 0x0000), NULL },
		{ mk_mii_end, }
	};
static phy_info_t const phy_info_lxt971 = {
	.id = 0x0001378e,
	.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
};

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

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

	switch((mii_reg >> 2) & 7) {
	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;
	*s = status;
}

static phy_cmd_t const phy_cmd_qs6612_config[] = {
		/* The PHY powers up isolated on the RPX,
Linus Torvalds's avatar
Linus Torvalds committed
		 * 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, }
	};
static phy_cmd_t const phy_cmd_qs6612_startup[] = {  /* enable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
		{ mk_mii_write(MII_QS6612_IMR, 0x003a), NULL },
		{ mk_mii_write(MII_REG_CR, 0x1200), NULL }, /* autonegotiate */
		{ mk_mii_end, }
	};
static phy_cmd_t const phy_cmd_qs6612_ack_int[] = {
Linus Torvalds's avatar
Linus Torvalds committed
		/* 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, }
	};
static phy_cmd_t const phy_cmd_qs6612_shutdown[] = { /* disable interrupts */
Linus Torvalds's avatar
Linus Torvalds committed
		{ mk_mii_write(MII_QS6612_IMR, 0x0000), NULL },
		{ mk_mii_end, }
	};
static phy_info_t const phy_info_qs6612 = {
	.id = 0x00181440,
	.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
};

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