[PATCH] FS_ENET: use PAL for mii management (5b4b8454) · Commits · e / devices / android_kernel_teracube_2e

drivers/net/fs_enet/Makefile

+3 −3

Original line number	Original line	Diff line number	Diff line
	@@ -4,7 +4,7 @@

	obj-$(CONFIG_FS_ENET) += fs_enet.o		obj-$(CONFIG_FS_ENET) += fs_enet.o

	obj-$(CONFIG_8xx) += mac-fec.o mac-scc.o		obj-$(CONFIG_8xx) += mac-fec.o mac-scc.o mii-fec.o
	obj-$(CONFIG_8260) += mac-fcc.o		obj-$(CONFIG_CPM2) += mac-fcc.o mii-bitbang.o

	fs_enet-objs := fs_enet-main.o fs_enet-mii.o mii-bitbang.o mii-fixed.o		fs_enet-objs := fs_enet-main.o

drivers/net/fs_enet/fec.h

0 → 100644

+42 −0

Original line number	Original line	Diff line number	Diff line
			#ifndef FS_ENET_FEC_H
			#define FS_ENET_FEC_H

			/* CRC polynomium used by the FEC for the multicast group filtering */
			#define FEC_CRC_POLY 0x04C11DB7

			#define FEC_MAX_MULTICAST_ADDRS 64

			/* Interrupt events/masks.
			*/
			#define FEC_ENET_HBERR 0x80000000U /* Heartbeat error */
			#define FEC_ENET_BABR 0x40000000U /* Babbling receiver */
			#define FEC_ENET_BABT 0x20000000U /* Babbling transmitter */
			#define FEC_ENET_GRA 0x10000000U /* Graceful stop complete */
			#define FEC_ENET_TXF 0x08000000U /* Full frame transmitted */
			#define FEC_ENET_TXB 0x04000000U /* A buffer was transmitted */
			#define FEC_ENET_RXF 0x02000000U /* Full frame received */
			#define FEC_ENET_RXB 0x01000000U /* A buffer was received */
			#define FEC_ENET_MII 0x00800000U /* MII interrupt */
			#define FEC_ENET_EBERR 0x00400000U /* SDMA bus error */

			#define FEC_ECNTRL_PINMUX 0x00000004
			#define FEC_ECNTRL_ETHER_EN 0x00000002
			#define FEC_ECNTRL_RESET 0x00000001

			#define FEC_RCNTRL_BC_REJ 0x00000010
			#define FEC_RCNTRL_PROM 0x00000008
			#define FEC_RCNTRL_MII_MODE 0x00000004
			#define FEC_RCNTRL_DRT 0x00000002
			#define FEC_RCNTRL_LOOP 0x00000001

			#define FEC_TCNTRL_FDEN 0x00000004
			#define FEC_TCNTRL_HBC 0x00000002
			#define FEC_TCNTRL_GTS 0x00000001



			/*
			* Delay to wait for FEC reset command to complete (in us)
			*/
			#define FEC_RESET_DELAY 50
			#endif

drivers/net/fs_enet/fs_enet-main.c

+129 −78

Original line number	Original line	Diff line number	Diff line
	@@ -37,6 +37,7 @@
	#include <linux/bitops.h>		#include <linux/bitops.h>
	#include <linux/fs.h>		#include <linux/fs.h>
	#include <linux/platform_device.h>		#include <linux/platform_device.h>
			#include <linux/phy.h>

	#include <linux/vmalloc.h>		#include <linux/vmalloc.h>
	#include <asm/pgtable.h>		#include <asm/pgtable.h>
	@@ -682,35 +683,6 @@ static void fs_free_irq(struct net_device *dev, int irq)
	(*fep->ops->post_free_irq)(dev, irq);		(*fep->ops->post_free_irq)(dev, irq);
	}		}

	/**********************************************************************************/

	/* This interrupt occurs when the PHY detects a link change. */
	static irqreturn_t
	fs_mii_link_interrupt(int irq, void dev_id, struct pt_regs regs)
	{
	struct net_device *dev = dev_id;
	struct fs_enet_private *fep;
	const struct fs_platform_info *fpi;

	fep = netdev_priv(dev);
	fpi = fep->fpi;

	/*
	* Acknowledge the interrupt if possible. If we have not
	* found the PHY yet we can't process or acknowledge the
	* interrupt now. Instead we ignore this interrupt for now,
	* which we can do since it is edge triggered. It will be
	* acknowledged later by fs_enet_open().
	*/
	if (!fep->phy)
	return IRQ_NONE;

	fs_mii_ack_int(dev);
	fs_mii_link_status_change_check(dev, 0);

	return IRQ_HANDLED;
	}

	static void fs_timeout(struct net_device *dev)		static void fs_timeout(struct net_device *dev)
	{		{
	struct fs_enet_private *fep = netdev_priv(dev);		struct fs_enet_private *fep = netdev_priv(dev);
	@@ -722,10 +694,13 @@ static void fs_timeout(struct net_device *dev)
	spin_lock_irqsave(&fep->lock, flags);		spin_lock_irqsave(&fep->lock, flags);

	if (dev->flags & IFF_UP) {		if (dev->flags & IFF_UP) {
			phy_stop(fep->phydev);
	(*fep->ops->stop)(dev);		(*fep->ops->stop)(dev);
	(*fep->ops->restart)(dev);		(*fep->ops->restart)(dev);
			phy_start(fep->phydev);
	}		}

			phy_start(fep->phydev);
	wake = fep->tx_free && !(CBDR_SC(fep->cur_tx) & BD_ENET_TX_READY);		wake = fep->tx_free && !(CBDR_SC(fep->cur_tx) & BD_ENET_TX_READY);
	spin_unlock_irqrestore(&fep->lock, flags);		spin_unlock_irqrestore(&fep->lock, flags);

	@@ -733,35 +708,112 @@ static void fs_timeout(struct net_device *dev)
	netif_wake_queue(dev);		netif_wake_queue(dev);
	}		}

			/*-----------------------------------------------------------------------------
			* generic link-change handler - should be sufficient for most cases
			-----------------------------------------------------------------------------/
			static void generic_adjust_link(struct net_device *dev)
			{
			struct fs_enet_private *fep = netdev_priv(dev);
			struct phy_device *phydev = fep->phydev;
			int new_state = 0;

			if (phydev->link) {

			/* adjust to duplex mode */
			if (phydev->duplex != fep->oldduplex){
			new_state = 1;
			fep->oldduplex = phydev->duplex;
			}

			if (phydev->speed != fep->oldspeed) {
			new_state = 1;
			fep->oldspeed = phydev->speed;
			}

			if (!fep->oldlink) {
			new_state = 1;
			fep->oldlink = 1;
			netif_schedule(dev);
			netif_carrier_on(dev);
			netif_start_queue(dev);
			}

			if (new_state)
			fep->ops->restart(dev);

			} else if (fep->oldlink) {
			new_state = 1;
			fep->oldlink = 0;
			fep->oldspeed = 0;
			fep->oldduplex = -1;
			netif_carrier_off(dev);
			netif_stop_queue(dev);
			}

			if (new_state && netif_msg_link(fep))
			phy_print_status(phydev);
			}


			static void fs_adjust_link(struct net_device *dev)
			{
			struct fs_enet_private *fep = netdev_priv(dev);
			unsigned long flags;

			spin_lock_irqsave(&fep->lock, flags);

			if(fep->ops->adjust_link)
			fep->ops->adjust_link(dev);
			else
			generic_adjust_link(dev);

			spin_unlock_irqrestore(&fep->lock, flags);
			}

			static int fs_init_phy(struct net_device *dev)
			{
			struct fs_enet_private *fep = netdev_priv(dev);
			struct phy_device *phydev;

			fep->oldlink = 0;
			fep->oldspeed = 0;
			fep->oldduplex = -1;
			if(fep->fpi->bus_id)
			phydev = phy_connect(dev, fep->fpi->bus_id, &fs_adjust_link, 0);
			else {
			printk("No phy bus ID specified in BSP code\n");
			return -EINVAL;
			}
			if (IS_ERR(phydev)) {
			printk(KERN_ERR "%s: Could not attach to PHY\n", dev->name);
			return PTR_ERR(phydev);
			}

			fep->phydev = phydev;

			return 0;
			}


	static int fs_enet_open(struct net_device *dev)		static int fs_enet_open(struct net_device *dev)
	{		{
	struct fs_enet_private *fep = netdev_priv(dev);		struct fs_enet_private *fep = netdev_priv(dev);
	const struct fs_platform_info *fpi = fep->fpi;
	int r;		int r;
			int err;

	/* Install our interrupt handler. */		/* Install our interrupt handler. */
	r = fs_request_irq(dev, fep->interrupt, "fs_enet-mac", fs_enet_interrupt);		r = fs_request_irq(dev, fep->interrupt, "fs_enet-mac", fs_enet_interrupt);
	if (r != 0) {		if (r != 0) {
	printk(KERN_ERR DRV_MODULE_NAME		printk(KERN_ERR DRV_MODULE_NAME
	": %s Could not allocate FEC IRQ!", dev->name);		": %s Could not allocate FS_ENET IRQ!", dev->name);
	return -EINVAL;		return -EINVAL;
	}		}

	/* Install our phy interrupt handler */		err = fs_init_phy(dev);
	if (fpi->phy_irq != -1) {		if(err)
			return err;
	r = fs_request_irq(dev, fpi->phy_irq, "fs_enet-phy", fs_mii_link_interrupt);
	if (r != 0) {
	printk(KERN_ERR DRV_MODULE_NAME
	": %s Could not allocate PHY IRQ!", dev->name);
	fs_free_irq(dev, fep->interrupt);
	return -EINVAL;
	}
	}

	fs_mii_startup(dev);		phy_start(fep->phydev);
	netif_carrier_off(dev);
	fs_mii_link_status_change_check(dev, 1);

	return 0;		return 0;
	}		}
	@@ -769,20 +821,19 @@ static int fs_enet_open(struct net_device *dev)
	static int fs_enet_close(struct net_device *dev)		static int fs_enet_close(struct net_device *dev)
	{		{
	struct fs_enet_private *fep = netdev_priv(dev);		struct fs_enet_private *fep = netdev_priv(dev);
	const struct fs_platform_info *fpi = fep->fpi;
	unsigned long flags;		unsigned long flags;

	netif_stop_queue(dev);		netif_stop_queue(dev);
	netif_carrier_off(dev);		netif_carrier_off(dev);
	fs_mii_shutdown(dev);		phy_stop(fep->phydev);

	spin_lock_irqsave(&fep->lock, flags);		spin_lock_irqsave(&fep->lock, flags);
	(*fep->ops->stop)(dev);		(*fep->ops->stop)(dev);
	spin_unlock_irqrestore(&fep->lock, flags);		spin_unlock_irqrestore(&fep->lock, flags);

	/* release any irqs */		/* release any irqs */
	if (fpi->phy_irq != -1)		phy_disconnect(fep->phydev);
	fs_free_irq(dev, fpi->phy_irq);		fep->phydev = NULL;
	fs_free_irq(dev, fep->interrupt);		fs_free_irq(dev, fep->interrupt);

	return 0;		return 0;
	@@ -830,33 +881,19 @@ static void fs_get_regs(struct net_device dev, struct ethtool_regs regs,
	static int fs_get_settings(struct net_device dev, struct ethtool_cmd cmd)		static int fs_get_settings(struct net_device dev, struct ethtool_cmd cmd)
	{		{
	struct fs_enet_private *fep = netdev_priv(dev);		struct fs_enet_private *fep = netdev_priv(dev);
	unsigned long flags;		return phy_ethtool_gset(fep->phydev, cmd);
	int rc;

	spin_lock_irqsave(&fep->lock, flags);
	rc = mii_ethtool_gset(&fep->mii_if, cmd);
	spin_unlock_irqrestore(&fep->lock, flags);

	return rc;
	}		}

	static int fs_set_settings(struct net_device dev, struct ethtool_cmd cmd)		static int fs_set_settings(struct net_device dev, struct ethtool_cmd cmd)
	{		{
	struct fs_enet_private *fep = netdev_priv(dev);		struct fs_enet_private *fep = netdev_priv(dev);
	unsigned long flags;		phy_ethtool_sset(fep->phydev, cmd);
	int rc;		return 0;

	spin_lock_irqsave(&fep->lock, flags);
	rc = mii_ethtool_sset(&fep->mii_if, cmd);
	spin_unlock_irqrestore(&fep->lock, flags);

	return rc;
	}		}

	static int fs_nway_reset(struct net_device *dev)		static int fs_nway_reset(struct net_device *dev)
	{		{
	struct fs_enet_private *fep = netdev_priv(dev);		return 0;
	return mii_nway_restart(&fep->mii_if);
	}		}

	static u32 fs_get_msglevel(struct net_device *dev)		static u32 fs_get_msglevel(struct net_device *dev)
	@@ -898,7 +935,7 @@ static int fs_ioctl(struct net_device dev, struct ifreq rq, int cmd)
	return -EINVAL;		return -EINVAL;

	spin_lock_irqsave(&fep->lock, flags);		spin_lock_irqsave(&fep->lock, flags);
	rc = generic_mii_ioctl(&fep->mii_if, mii, cmd, NULL);		rc = phy_mii_ioctl(fep->phydev, mii, cmd);
	spin_unlock_irqrestore(&fep->lock, flags);		spin_unlock_irqrestore(&fep->lock, flags);
	return rc;		return rc;
	}		}
	@@ -1030,12 +1067,6 @@ static struct net_device fs_init_instance(struct device dev,
	}		}
	registered = 1;		registered = 1;

	err = fs_mii_connect(ndev);
	if (err != 0) {
	printk(KERN_ERR DRV_MODULE_NAME
	": %s fs_mii_connect failed.\n", ndev->name);
	goto err;
	}

	return ndev;		return ndev;

	@@ -1073,8 +1104,6 @@ static int fs_cleanup_instance(struct net_device *ndev)

	fpi = fep->fpi;		fpi = fep->fpi;

	fs_mii_disconnect(ndev);

	unregister_netdev(ndev);		unregister_netdev(ndev);

	dma_free_coherent(fep->dev, (fpi->tx_ring + fpi->rx_ring) * sizeof(cbd_t),		dma_free_coherent(fep->dev, (fpi->tx_ring + fpi->rx_ring) * sizeof(cbd_t),
	@@ -1196,17 +1225,39 @@ static int __init fs_init(void)
	r = setup_immap();		r = setup_immap();
	if (r != 0)		if (r != 0)
	return r;		return r;
	r = driver_register(&fs_enet_fec_driver);
			#ifdef CONFIG_FS_ENET_HAS_FCC
			/* let's insert mii stuff */
			r = fs_enet_mdio_bb_init();

			if (r != 0) {
			printk(KERN_ERR DRV_MODULE_NAME
			"BB PHY init failed.\n");
			return r;
			}
			r = driver_register(&fs_enet_fcc_driver);
	if (r != 0)		if (r != 0)
	goto err;		goto err;
			#endif

	r = driver_register(&fs_enet_fcc_driver);		#ifdef CONFIG_FS_ENET_HAS_FEC
			r = fs_enet_mdio_fec_init();
			if (r != 0) {
			printk(KERN_ERR DRV_MODULE_NAME
			"FEC PHY init failed.\n");
			return r;
			}

			r = driver_register(&fs_enet_fec_driver);
	if (r != 0)		if (r != 0)
	goto err;		goto err;
			#endif

			#ifdef CONFIG_FS_ENET_HAS_SCC
	r = driver_register(&fs_enet_scc_driver);		r = driver_register(&fs_enet_scc_driver);
	if (r != 0)		if (r != 0)
	goto err;		goto err;
			#endif

	return 0;		return 0;
	err:		err:

drivers/net/fs_enet/fs_enet-mii.c

deleted100644 → 0

+0 −505

Original line number	Original line	Diff line number	Diff line
	/*
	* Combined Ethernet driver for Motorola MPC8xx and MPC82xx.
	*
	* Copyright (c) 2003 Intracom S.A.
	* by Pantelis Antoniou <panto@intracom.gr>
	*
	* 2005 (c) MontaVista Software, Inc.
	* Vitaly Bordug <vbordug@ru.mvista.com>
	*
	* Heavily based on original FEC driver by Dan Malek <dan@embeddededge.com>
	* and modifications by Joakim Tjernlund <joakim.tjernlund@lumentis.se>
	*
	* This file is licensed under the terms of the GNU General Public License
	* version 2. This program is licensed "as is" without any warranty of any
	* kind, whether express or implied.
	*/


	#include <linux/module.h>
	#include <linux/types.h>
	#include <linux/kernel.h>
	#include <linux/sched.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/mii.h>
	#include <linux/ethtool.h>
	#include <linux/bitops.h>

	#include <asm/pgtable.h>
	#include <asm/irq.h>
	#include <asm/uaccess.h>

	#include "fs_enet.h"

	/*************************************************/

	/*
	* Generic PHY support.
	* Should work for all PHYs, but link change is detected by polling
	*/

	static void generic_timer_callback(unsigned long data)
	{
	struct net_device dev = (struct net_device )data;
	struct fs_enet_private *fep = netdev_priv(dev);

	fep->phy_timer_list.expires = jiffies + HZ / 2;

	add_timer(&fep->phy_timer_list);

	fs_mii_link_status_change_check(dev, 0);
	}

	static void generic_startup(struct net_device *dev)
	{
	struct fs_enet_private *fep = netdev_priv(dev);

	fep->phy_timer_list.expires = jiffies + HZ / 2; /* every 500ms */
	fep->phy_timer_list.data = (unsigned long)dev;
	fep->phy_timer_list.function = generic_timer_callback;
	add_timer(&fep->phy_timer_list);
	}

	static void generic_shutdown(struct net_device *dev)
	{
	struct fs_enet_private *fep = netdev_priv(dev);

	del_timer_sync(&fep->phy_timer_list);
	}

	/* ------------------------------------------------------------------------- */
	/* The Davicom DM9161 is used on the NETTA board */

	/* register definitions */

	#define MII_DM9161_ANAR 4 /* Aux. Config Register */
	#define MII_DM9161_ACR 16 /* Aux. Config Register */
	#define MII_DM9161_ACSR 17 /* Aux. Config/Status Register */
	#define MII_DM9161_10TCSR 18 /* 10BaseT Config/Status Reg. */
	#define MII_DM9161_INTR 21 /* Interrupt Register */
	#define MII_DM9161_RECR 22 /* Receive Error Counter Reg. */
	#define MII_DM9161_DISCR 23 /* Disconnect Counter Register */

	static void dm9161_startup(struct net_device *dev)
	{
	struct fs_enet_private *fep = netdev_priv(dev);

	fs_mii_write(dev, fep->mii_if.phy_id, MII_DM9161_INTR, 0x0000);
	/* Start autonegotiation */
	fs_mii_write(dev, fep->mii_if.phy_id, MII_BMCR, 0x1200);

	set_current_state(TASK_UNINTERRUPTIBLE);
	schedule_timeout(HZ*8);
	}

	static void dm9161_ack_int(struct net_device *dev)
	{
	struct fs_enet_private *fep = netdev_priv(dev);

	fs_mii_read(dev, fep->mii_if.phy_id, MII_DM9161_INTR);
	}

	static void dm9161_shutdown(struct net_device *dev)
	{
	struct fs_enet_private *fep = netdev_priv(dev);

	fs_mii_write(dev, fep->mii_if.phy_id, MII_DM9161_INTR, 0x0f00);
	}

	/**********************************************************************************/

	static const struct phy_info phy_info[] = {
	{
	.id = 0x00181b88,
	.name = "DM9161",
	.startup = dm9161_startup,
	.ack_int = dm9161_ack_int,
	.shutdown = dm9161_shutdown,
	}, {
	.id = 0,
	.name = "GENERIC",
	.startup = generic_startup,
	.shutdown = generic_shutdown,
	},
	};

	/**********************************************************************************/

	static int phy_id_detect(struct net_device *dev)
	{
	struct fs_enet_private *fep = netdev_priv(dev);
	const struct fs_platform_info *fpi = fep->fpi;
	struct fs_enet_mii_bus *bus = fep->mii_bus;
	int i, r, start, end, phytype, physubtype;
	const struct phy_info *phy;
	int phy_hwid, phy_id;

	phy_hwid = -1;
	fep->phy = NULL;

	/* auto-detect? */
	if (fpi->phy_addr == -1) {
	start = 1;
	end = 32;
	} else { /* direct */
	start = fpi->phy_addr;
	end = start + 1;
	}

	for (phy_id = start; phy_id < end; phy_id++) {
	/* skip already used phy addresses on this bus */
	if (bus->usage_map & (1 << phy_id))
	continue;
	r = fs_mii_read(dev, phy_id, MII_PHYSID1);
	if (r == -1 \|\| (phytype = (r & 0xffff)) == 0xffff)
	continue;
	r = fs_mii_read(dev, phy_id, MII_PHYSID2);
	if (r == -1 \|\| (physubtype = (r & 0xffff)) == 0xffff)
	continue;
	phy_hwid = (phytype << 16) \| physubtype;
	if (phy_hwid != -1)
	break;
	}

	if (phy_hwid == -1) {
	printk(KERN_ERR DRV_MODULE_NAME
	": %s No PHY detected! range=0x%02x-0x%02x\n",
	dev->name, start, end);
	return -1;
	}

	for (i = 0, phy = phy_info; i < ARRAY_SIZE(phy_info); i++, phy++)
	if (phy->id == (phy_hwid >> 4) \|\| phy->id == 0)
	break;

	if (i >= ARRAY_SIZE(phy_info)) {
	printk(KERN_ERR DRV_MODULE_NAME
	": %s PHY id 0x%08x is not supported!\n",
	dev->name, phy_hwid);
	return -1;
	}

	fep->phy = phy;

	/* mark this address as used */
	bus->usage_map \|= (1 << phy_id);

	printk(KERN_INFO DRV_MODULE_NAME
	": %s Phy @ 0x%x, type %s (0x%08x)%s\n",
	dev->name, phy_id, fep->phy->name, phy_hwid,
	fpi->phy_addr == -1 ? " (auto-detected)" : "");

	return phy_id;
	}

	void fs_mii_startup(struct net_device *dev)
	{
	struct fs_enet_private *fep = netdev_priv(dev);

	if (fep->phy->startup)
	(*fep->phy->startup) (dev);
	}

	void fs_mii_shutdown(struct net_device *dev)
	{
	struct fs_enet_private *fep = netdev_priv(dev);

	if (fep->phy->shutdown)
	(*fep->phy->shutdown) (dev);
	}

	void fs_mii_ack_int(struct net_device *dev)
	{
	struct fs_enet_private *fep = netdev_priv(dev);

	if (fep->phy->ack_int)
	(*fep->phy->ack_int) (dev);
	}

	#define MII_LINK 0x0001
	#define MII_HALF 0x0002
	#define MII_FULL 0x0004
	#define MII_BASE4 0x0008
	#define MII_10M 0x0010
	#define MII_100M 0x0020
	#define MII_1G 0x0040
	#define MII_10G 0x0080

	/* return full mii info at one gulp, with a usable form */
	static unsigned int mii_full_status(struct mii_if_info *mii)
	{
	unsigned int status;
	int bmsr, adv, lpa, neg;
	struct fs_enet_private* fep = netdev_priv(mii->dev);

	/* first, a dummy read, needed to latch some MII phys */
	(void)mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);
	bmsr = mii->mdio_read(mii->dev, mii->phy_id, MII_BMSR);

	/* no link */
	if ((bmsr & BMSR_LSTATUS) == 0)
	return 0;

	status = MII_LINK;

	/* Lets look what ANEG says if it's supported - otherwize we shall
	take the right values from the platform info*/
	if(!mii->force_media) {
	/* autoneg not completed; don't bother */
	if ((bmsr & BMSR_ANEGCOMPLETE) == 0)
	return 0;

	adv = (*mii->mdio_read)(mii->dev, mii->phy_id, MII_ADVERTISE);
	lpa = (*mii->mdio_read)(mii->dev, mii->phy_id, MII_LPA);

	neg = lpa & adv;
	} else {
	neg = fep->fpi->bus_info->lpa;
	}

	if (neg & LPA_100FULL)
	status \|= MII_FULL \| MII_100M;
	else if (neg & LPA_100BASE4)
	status \|= MII_FULL \| MII_BASE4 \| MII_100M;
	else if (neg & LPA_100HALF)
	status \|= MII_HALF \| MII_100M;
	else if (neg & LPA_10FULL)
	status \|= MII_FULL \| MII_10M;
	else
	status \|= MII_HALF \| MII_10M;

	return status;
	}

	void fs_mii_link_status_change_check(struct net_device *dev, int init_media)
	{
	struct fs_enet_private *fep = netdev_priv(dev);
	struct mii_if_info *mii = &fep->mii_if;
	unsigned int mii_status;
	int ok_to_print, link, duplex, speed;
	unsigned long flags;

	ok_to_print = netif_msg_link(fep);

	mii_status = mii_full_status(mii);

	if (!init_media && mii_status == fep->last_mii_status)
	return;

	fep->last_mii_status = mii_status;

	link = !!(mii_status & MII_LINK);
	duplex = !!(mii_status & MII_FULL);
	speed = (mii_status & MII_100M) ? 100 : 10;

	if (link == 0) {
	netif_carrier_off(mii->dev);
	netif_stop_queue(dev);
	if (!init_media) {
	spin_lock_irqsave(&fep->lock, flags);
	(*fep->ops->stop)(dev);
	spin_unlock_irqrestore(&fep->lock, flags);
	}

	if (ok_to_print)
	printk(KERN_INFO "%s: link down\n", mii->dev->name);

	} else {

	mii->full_duplex = duplex;

	netif_carrier_on(mii->dev);

	spin_lock_irqsave(&fep->lock, flags);
	fep->duplex = duplex;
	fep->speed = speed;
	(*fep->ops->restart)(dev);
	spin_unlock_irqrestore(&fep->lock, flags);

	netif_start_queue(dev);

	if (ok_to_print)
	printk(KERN_INFO "%s: link up, %dMbps, %s-duplex\n",
	dev->name, speed, duplex ? "full" : "half");
	}
	}

	/**********************************************************************************/

	int fs_mii_read(struct net_device *dev, int phy_id, int location)
	{
	struct fs_enet_private *fep = netdev_priv(dev);
	struct fs_enet_mii_bus *bus = fep->mii_bus;

	unsigned long flags;
	int ret;

	spin_lock_irqsave(&bus->mii_lock, flags);
	ret = (*bus->mii_read)(bus, phy_id, location);
	spin_unlock_irqrestore(&bus->mii_lock, flags);

	return ret;
	}

	void fs_mii_write(struct net_device *dev, int phy_id, int location, int value)
	{
	struct fs_enet_private *fep = netdev_priv(dev);
	struct fs_enet_mii_bus *bus = fep->mii_bus;
	unsigned long flags;

	spin_lock_irqsave(&bus->mii_lock, flags);
	(*bus->mii_write)(bus, phy_id, location, value);
	spin_unlock_irqrestore(&bus->mii_lock, flags);
	}

	/*****************************************************************************/

	/* list of all registered mii buses */
	static LIST_HEAD(fs_mii_bus_list);

	static struct fs_enet_mii_bus *lookup_bus(int method, int id)
	{
	struct list_head *ptr;
	struct fs_enet_mii_bus *bus;

	list_for_each(ptr, &fs_mii_bus_list) {
	bus = list_entry(ptr, struct fs_enet_mii_bus, list);
	if (bus->bus_info->method == method &&
	bus->bus_info->id == id)
	return bus;
	}
	return NULL;
	}

	static struct fs_enet_mii_bus create_bus(const struct fs_mii_bus_info bi)
	{
	struct fs_enet_mii_bus *bus;
	int ret = 0;

	bus = kmalloc(sizeof(*bus), GFP_KERNEL);
	if (bus == NULL) {
	ret = -ENOMEM;
	goto err;
	}
	memset(bus, 0, sizeof(*bus));
	spin_lock_init(&bus->mii_lock);
	bus->bus_info = bi;
	bus->refs = 0;
	bus->usage_map = 0;

	/* perform initialization */
	switch (bi->method) {

	case fsmii_fixed:
	ret = fs_mii_fixed_init(bus);
	if (ret != 0)
	goto err;
	break;

	case fsmii_bitbang:
	ret = fs_mii_bitbang_init(bus);
	if (ret != 0)
	goto err;
	break;
	#ifdef CONFIG_FS_ENET_HAS_FEC
	case fsmii_fec:
	ret = fs_mii_fec_init(bus);
	if (ret != 0)
	goto err;
	break;
	#endif
	default:
	ret = -EINVAL;
	goto err;
	}

	list_add(&bus->list, &fs_mii_bus_list);

	return bus;

	err:
	kfree(bus);
	return ERR_PTR(ret);
	}

	static void destroy_bus(struct fs_enet_mii_bus *bus)
	{
	/* remove from bus list */
	list_del(&bus->list);

	/* nothing more needed */
	kfree(bus);
	}

	int fs_mii_connect(struct net_device *dev)
	{
	struct fs_enet_private *fep = netdev_priv(dev);
	const struct fs_platform_info *fpi = fep->fpi;
	struct fs_enet_mii_bus *bus = NULL;

	/* check method validity */
	switch (fpi->bus_info->method) {
	case fsmii_fixed:
	case fsmii_bitbang:
	break;
	#ifdef CONFIG_FS_ENET_HAS_FEC
	case fsmii_fec:
	break;
	#endif
	default:
	printk(KERN_ERR DRV_MODULE_NAME
	": %s Unknown MII bus method (%d)!\n",
	dev->name, fpi->bus_info->method);
	return -EINVAL;
	}

	bus = lookup_bus(fpi->bus_info->method, fpi->bus_info->id);

	/* if not found create new bus */
	if (bus == NULL) {
	bus = create_bus(fpi->bus_info);
	if (IS_ERR(bus)) {
	printk(KERN_ERR DRV_MODULE_NAME
	": %s MII bus creation failure!\n", dev->name);
	return PTR_ERR(bus);
	}
	}

	bus->refs++;

	fep->mii_bus = bus;

	fep->mii_if.dev = dev;
	fep->mii_if.phy_id_mask = 0x1f;
	fep->mii_if.reg_num_mask = 0x1f;
	fep->mii_if.mdio_read = fs_mii_read;
	fep->mii_if.mdio_write = fs_mii_write;
	fep->mii_if.force_media = fpi->bus_info->disable_aneg;
	fep->mii_if.phy_id = phy_id_detect(dev);

	return 0;
	}

	void fs_mii_disconnect(struct net_device *dev)
	{
	struct fs_enet_private *fep = netdev_priv(dev);
	struct fs_enet_mii_bus *bus = NULL;

	bus = fep->mii_bus;
	fep->mii_bus = NULL;

	if (--bus->refs <= 0)
	destroy_bus(bus);
	}

drivers/net/fs_enet/fs_enet.h

+25 −15

Original line number	Original line	Diff line number	Diff line
	@@ -5,6 +5,7 @@
	#include <linux/netdevice.h>		#include <linux/netdevice.h>
	#include <linux/types.h>		#include <linux/types.h>
	#include <linux/list.h>		#include <linux/list.h>
			#include <linux/phy.h>

	#include <linux/fs_enet_pd.h>		#include <linux/fs_enet_pd.h>

	@@ -12,12 +13,30 @@

	#ifdef CONFIG_CPM1		#ifdef CONFIG_CPM1
	#include <asm/commproc.h>		#include <asm/commproc.h>

			struct fec_info {
			fec_t* fecp;
			u32 mii_speed;
			};
	#endif		#endif

	#ifdef CONFIG_CPM2		#ifdef CONFIG_CPM2
	#include <asm/cpm2.h>		#include <asm/cpm2.h>
	#endif		#endif

			/* This is used to operate with pins.
			Note that the actual port size may
			be different; cpm(s) handle it OK */
			struct bb_info {
			u8 mdio_dat_msk;
			u8 mdio_dir_msk;
			u8 *mdio_dir;
			u8 *mdio_dat;
			u8 mdc_msk;
			u8 *mdc_dat;
			int delay;
			};

	/* hw driver ops */		/* hw driver ops */
	struct fs_ops {		struct fs_ops {
	int (setup_data)(struct net_device dev);		int (setup_data)(struct net_device dev);
	@@ -25,6 +44,7 @@ struct fs_ops {
	void (free_bd)(struct net_device dev);		void (free_bd)(struct net_device dev);
	void (cleanup_data)(struct net_device dev);		void (cleanup_data)(struct net_device dev);
	void (set_multicast_list)(struct net_device dev);		void (set_multicast_list)(struct net_device dev);
			void (adjust_link)(struct net_device dev);
	void (restart)(struct net_device dev);		void (restart)(struct net_device dev);
	void (stop)(struct net_device dev);		void (stop)(struct net_device dev);
	void (pre_request_irq)(struct net_device dev, int irq);		void (pre_request_irq)(struct net_device dev, int irq);
	@@ -100,10 +120,6 @@ struct fs_enet_mii_bus {
	};		};
	};		};

	int fs_mii_bitbang_init(struct fs_enet_mii_bus *bus);
	int fs_mii_fixed_init(struct fs_enet_mii_bus *bus);
	int fs_mii_fec_init(struct fs_enet_mii_bus *bus);

	struct fs_enet_private {		struct fs_enet_private {
	struct device dev; / pointer back to the device (must be initialized first) */		struct device dev; / pointer back to the device (must be initialized first) */
	spinlock_t lock; /* during all ops except TX pckt processing */		spinlock_t lock; /* during all ops except TX pckt processing */
	@@ -130,7 +146,8 @@ struct fs_enet_private {
	struct fs_enet_mii_bus *mii_bus;		struct fs_enet_mii_bus *mii_bus;
	int interrupt;		int interrupt;

	int duplex, speed; /* current settings */		struct phy_device *phydev;
			int oldduplex, oldspeed, oldlink; /* current settings */

	/* event masks */		/* event masks */
	u32 ev_napi_rx; /* mask of NAPI rx events */		u32 ev_napi_rx; /* mask of NAPI rx events */
	@@ -168,15 +185,9 @@ struct fs_enet_private {
	};		};

	/***************************************************************************/		/***************************************************************************/
			int fs_enet_mdio_bb_init(void);
	int fs_mii_read(struct net_device *dev, int phy_id, int location);		int fs_mii_fixed_init(struct fs_enet_mii_bus *bus);
	void fs_mii_write(struct net_device *dev, int phy_id, int location, int value);		int fs_enet_mdio_fec_init(void);

	void fs_mii_startup(struct net_device *dev);
	void fs_mii_shutdown(struct net_device *dev);
	void fs_mii_ack_int(struct net_device *dev);

	void fs_mii_link_status_change_check(struct net_device *dev, int init_media);

	void fs_init_bds(struct net_device *dev);		void fs_init_bds(struct net_device *dev);
	void fs_cleanup_bds(struct net_device *dev);		void fs_cleanup_bds(struct net_device *dev);
	@@ -194,7 +205,6 @@ int fs_enet_platform_init(void);
	void fs_enet_platform_cleanup(void);		void fs_enet_platform_cleanup(void);

	/***************************************************************************/		/***************************************************************************/

	/* buffer descriptor access macros */		/* buffer descriptor access macros */

	/* access macros */		/* access macros */