mv643xx: ethernet driver updates

Index: linux-2.5-enet/drivers/net/mv643xx_eth.c
===================================================================
@@ -668,7 +668,7 @@
 	spin_lock_irq(&mp->lock);
 
 	err = request_irq(dev->irq, mv643xx_eth_int_handler,
-			SA_INTERRUPT | SA_SAMPLE_RANDOM, dev->name, dev);
+			SA_SHIRQ | SA_SAMPLE_RANDOM, dev->name, dev);
 
 	if (err) {
 		printk(KERN_ERR "Can not assign IRQ number to MV643XX_eth%d\n",

Index: linux-2.5-enet/drivers/net/mv643xx_eth.h
===================================================================
@@ -6,6 +6,7 @@
 #include <linux/kernel.h>
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
+#include <linux/mii.h>
 
 #include <linux/mv643xx.h>
 

@@ -397,6 +398,9 @@
 
 	u32 rx_int_coal;
 	u32 tx_int_coal;
+
+	u32 msg_enable;
+	struct mii_if_info mii;
 };
 
 /* ethernet.h API list */

132 lines not on this page · raw message

Index: linux-2.5-enet/drivers/net/mv643xx_eth.c
===================================================================
@@ -89,6 +89,7 @@
 static int ethernet_phy_detect(unsigned int eth_port_num);
 static int mv643xx_mdio_read(struct net_device *dev, int phy_id, int location);
 static void mv643xx_mdio_write(struct net_device *dev, int phy_id, int location, int val);
+static int mv643xx_eth_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
 static struct ethtool_ops mv643xx_ethtool_ops;
 
 static char mv643xx_driver_name[] = "mv643xx_eth";

@@ -670,6 +671,115 @@
 	return coal;
 }
 
+/* Set the mv643xx port configuration for the speed/duplex mode. 
+ * In the MV643XX PSCR, the following bits are defined:
+ * Bit2  - AN_Duplex, autoneg duplex, 0=>enable
+ * Bit13 - AN_Speed, autoneg speed, 0=>enable
+ * Bit21 - Set_Fdx, set full duplex. 1=>FD
+ * Bit23 - Set_GMII_Speed, 0=>10/100, 1=>1000
+ * Bit24 - Set_MII_Speed, 0=>10, 1=>100
+ */
+static void mv643xx_eth_update_pscr(struct net_device *dev,
+				   struct ethtool_cmd *cmd)
+{
+	struct mv643xx_private *mp = netdev_priv(dev);
+
+	mp->port_serial_control &= ~(BIT2 | BIT13 | BIT21 | BIT23 | BIT24);
+	if (!cmd->autoneg)
+		mp->port_serial_control |= BIT2 | BIT13;
+
+	if (cmd->duplex)
+		mp->port_serial_control |= BIT21;
+
+	if (cmd->speed == SPEED_100)
+		mp->port_serial_control |= BIT24;
+	else if (cmd->speed == SPEED_1000)
+		mp->port_serial_control |= BIT23;
+}
+
+static int mv643xx_set_settings(struct net_device *dev,
+				    struct ethtool_cmd *cmd)
+{
+	struct mv643xx_private *mp = netdev_priv(dev);
+	int err;
+
+	/* If we get here, the user wants to configure specific
+	 * settings.  There are 2 cases: autonegotiation on/off. When
+	 * autoneg is off, the PHY is forced to a specific mode. When
+	 * autoneg is on, we enable/disable specified negotiation
+	 * parameters.
+	 */
+	cmd->advertising &= ~(ADVERTISED_10baseT_Half |
+			      ADVERTISED_10baseT_Full |
+			      ADVERTISED_100baseT_Half |
+			      ADVERTISED_100baseT_Full |
+			      ADVERTISED_1000baseT_Half |
+			      ADVERTISED_1000baseT_Full);
+	if (!cmd->autoneg) {
+		switch (cmd->speed) {
+		case SPEED_10:
+			cmd->advertising |= ADVERTISED_10baseT_Half;
+			if (cmd->duplex == DUPLEX_FULL)
+				cmd->advertising |= ADVERTISED_10baseT_Full;
+			break;
+		case SPEED_100:
+			cmd->advertising |= ADVERTISED_100baseT_Half;
+			if (cmd->duplex == DUPLEX_FULL)
+				cmd->advertising |= ADVERTISED_100baseT_Full;
+			break;
+		case SPEED_1000:
+			if (cmd->duplex == DUPLEX_FULL)
+				cmd->advertising |= ADVERTISED_1000baseT_Full;
+			else
+				return -EINVAL;
+			break;
+		}
+	} else {
+		switch (cmd->speed) {
+		default:
+		case SPEED_1000:
+			if (cmd->duplex == DUPLEX_FULL)
+				cmd->advertising |= ADVERTISED_1000baseT_Full;
+			else
+				return -EINVAL;
+			/* NOBREAK */
+		case SPEED_100:
+			cmd->advertising |= ADVERTISED_100baseT_Half;
+			if (cmd->duplex == DUPLEX_FULL)
+				cmd->advertising |= ADVERTISED_100baseT_Full;
+			/* NOBREAK */
+		case SPEED_10:
+			cmd->advertising |= ADVERTISED_10baseT_Half;
+			if (cmd->duplex == DUPLEX_FULL)
+				cmd->advertising |= ADVERTISED_10baseT_Full;
+			/* NOBREAK */
+		}
+	}
+
+	/* Reconfigure the PHY */
+	err = mii_ethtool_sset(&mp->mii, cmd);
+	if (err)
+		return err;
+
+	mv643xx_eth_update_pscr(dev, cmd);
+
+	memcpy(&mp->ethtool_cmd, cmd, sizeof *cmd);
+
+	/* Restart the port with new settings. This will use the value
+	 * of port_serial_control that was configured above.
+	 */
+	if (netif_running(dev)) {
+		if (mv643xx_eth_real_stop(dev))
+			printk(KERN_ERR "%s: Fatal error on stopping "
+			       "device\n", dev->name);
+		if (mv643xx_eth_real_open(dev))
+			printk(KERN_ERR "%s: Fatal error on opening "
+			       "device\n", dev->name);
+	}
+
+	return 0;
+}
+
 /*
  * mv643xx_eth_open
  *

@@ -708,6 +818,9 @@
 	}
 
 	spin_unlock_irq(&mp->lock);
+	
+	if (mp->ethtool_cmd.autoneg || mp->ethtool_cmd.speed)
+		mv643xx_set_settings(dev, &mp->ethtool_cmd);
 
 	return 0;
 

@@ -1394,6 +1507,7 @@
 	u8 *p;
 	struct resource *res;
 	int err;
+	struct ethtool_cmd *ecmd;
 
 	dev = alloc_etherdev(sizeof(struct mv643xx_private));
 	if (!dev)

@@ -1431,6 +1545,7 @@
 	dev->tx_queue_len = mp->tx_ring_size;
 	dev->base_addr = 0;
 	dev->change_mtu = mv643xx_eth_change_mtu;
+	dev->do_ioctl = mv643xx_eth_do_ioctl;
 	SET_ETHTOOL_OPS(dev, &mv643xx_ethtool_ops);
 
 #ifdef MV643XX_CHECKSUM_OFFLOAD_TX

@@ -1443,15 +1558,6 @@
 #endif
 #endif
 
-	/* Hook up MII support for ethtool */
-	mp->mii.dev = dev;
-	mp->mii.mdio_read = mv643xx_mdio_read;
-	mp->mii.mdio_write = mv643xx_mdio_write;
-	mp->mii.phy_id = ethernet_phy_get(mp->port_num);
-	mp->mii.phy_id_mask = 0x3f;
-	mp->mii.reg_num_mask = 0x1f;
-	mp->mii.supports_gmii = 1;
-
 	/* Configure the timeout task */
 	INIT_WORK(&mp->tx_timeout_task,
 			(void (*)(void *))mv643xx_eth_tx_timeout_task, dev);

@@ -1460,33 +1566,20 @@
 
 	/* set default config values */
 	eth_port_uc_addr_get(dev, dev->dev_addr);
-	mp->port_config = MV643XX_ETH_PORT_CONFIG_DEFAULT_VALUE;
-	mp->port_config_extend = MV643XX_ETH_PORT_CONFIG_EXTEND_DEFAULT_VALUE;
-	mp->port_sdma_config = MV643XX_ETH_PORT_SDMA_CONFIG_DEFAULT_VALUE;
-	mp->port_serial_control = MV643XX_ETH_PORT_SERIAL_CONTROL_DEFAULT_VALUE;
+	mp->port_serial_control =
+		mv_read(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num));
+	mp->port_serial_control &= ~MV643XX_ETH_SERIAL_PORT_ENABLE;
+	mp->port_serial_control |= MV643XX_ETH_DISABLE_AUTO_NEG_FOR_FLOW_CTRL |
+				   MV643XX_ETH_SERIAL_PORT_CONTROL_RESERVED   |
+				   MV643XX_ETH_DO_NOT_FORCE_LINK_FAIL;
 	mp->rx_ring_size = MV643XX_ETH_PORT_DEFAULT_RECEIVE_QUEUE_SIZE;
 	mp->tx_ring_size = MV643XX_ETH_PORT_DEFAULT_TRANSMIT_QUEUE_SIZE;
 
 	pd = pdev->dev.platform_data;
 	if (pd) {
-		if (pd->mac_addr != NULL)
+		if (pd->mac_addr)
 			memcpy(dev->dev_addr, pd->mac_addr, 6);
 
-		if (pd->phy_addr || pd->force_phy_addr)
-			ethernet_phy_set(port_num, pd->phy_addr);
-
-		if (pd->port_config || pd->force_port_config)
-			mp->port_config = pd->port_config;
-
-		if (pd->port_config_extend || pd->force_port_config_extend)
-			mp->port_config_extend = pd->port_config_extend;
-
-		if (pd->port_sdma_config || pd->force_port_sdma_config)
-			mp->port_sdma_config = pd->port_sdma_config;
-
-		if (pd->port_serial_control || pd->force_port_serial_control)
-			mp->port_serial_control = pd->port_serial_control;
-
 		if (pd->rx_queue_size)
 			mp->rx_ring_size = pd->rx_queue_size;
 

@@ -1502,8 +1595,32 @@
 			mp->rx_sram_size = pd->rx_sram_size;
 			mp->rx_sram_addr = pd->rx_sram_addr;
 		}
+
+		if (pd->ethtool_cmd) {
+			ecmd = pd->ethtool_cmd;
+			if (ecmd->advertising == 0)
+				ecmd->advertising = ADVERTISED_10baseT_Half   |
+						    ADVERTISED_10baseT_Full   |
+						    ADVERTISED_100baseT_Half  |
+						    ADVERTISED_100baseT_Full  |
+						    ADVERTISED_1000baseT_Full |
+						    ADVERTISED_Autoneg	      |
+						    ADVERTISED_MII;
+
+			ethernet_phy_set(port_num, ecmd->phy_address);
+			memcpy(&mp->ethtool_cmd, ecmd, sizeof *ecmd);
+			mv643xx_eth_update_pscr(dev, ecmd);
+		}
 	}
 
+	/* Hook up MII support for ethtool */
+	mp->mii.dev = dev;
+	mp->mii.mdio_read = mv643xx_mdio_read;
+	mp->mii.mdio_write = mv643xx_mdio_write;
+	mp->mii.phy_id = ethernet_phy_get(port_num);
+	mp->mii.phy_id_mask = 0x3f;
+	mp->mii.reg_num_mask = 0x1f;
+
 	err = ethernet_phy_detect(port_num);
 	if (err) {
 		pr_debug("MV643xx ethernet port %d: "

@@ -1516,6 +1633,8 @@
 	if (err)
 		goto out;
 
+	mp->mii.supports_gmii = mii_check_gmii_support(&mp->mii);
+
 	p = dev->dev_addr;
 	printk(KERN_NOTICE
 		"%s: port %d with MAC address %02x:%02x:%02x:%02x:%02x:%02x\n",

@@ -1888,10 +2007,15 @@
 	eth_port_uc_addr_set(port_num, mp->port_mac_addr);
 
 	/* Assign port configuration and command. */
-	mv_write(MV643XX_ETH_PORT_CONFIG_REG(port_num), mp->port_config);
+	mv_write(MV643XX_ETH_PORT_CONFIG_REG(port_num),
+			  MV643XX_ETH_PORT_CONFIG_DEFAULT_VALUE);
 
 	mv_write(MV643XX_ETH_PORT_CONFIG_EXTEND_REG(port_num),
-						mp->port_config_extend);
+			  MV643XX_ETH_PORT_CONFIG_EXTEND_DEFAULT_VALUE);
+
+	/* the mv643xx users manual says the following read/write are needed */
+	mv_read(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num));
+	mv_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num), 0);
 
 
 	/* Increase the Rx side buffer size if supporting GigE */

@@ -1903,12 +2027,12 @@
 						mp->port_serial_control);
 
 	mv_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num),
-		mv_read(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num)) |
-						MV643XX_ETH_SERIAL_PORT_ENABLE);
+			mp->port_serial_control |
+			MV643XX_ETH_SERIAL_PORT_ENABLE);
 
 	/* Assign port SDMA configuration */
 	mv_write(MV643XX_ETH_SDMA_CONFIG_REG(port_num),
-							mp->port_sdma_config);
+			  MV643XX_ETH_PORT_SDMA_CONFIG_DEFAULT_VALUE);
 
 	/* Enable port Rx. */
 	mv_write(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(port_num),

@@ -2351,15 +2475,6 @@
 	mv_write(MV643XX_ETH_PORT_CONFIG_REG(eth_port_num), eth_config_reg);
 }
 
-static int eth_port_autoneg_supported(unsigned int eth_port_num)
-{
-	unsigned int phy_reg_data0;
-
-	eth_port_read_smi_reg(eth_port_num, 0, &phy_reg_data0);
-
-	return phy_reg_data0 & 0x1000;
-}
-
 /*
  * ethernet_get_config_reg - Get the port configuration register
  *

@@ -2908,106 +3023,17 @@
 static int
 mv643xx_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
 {
-	struct mv643xx_private *mp = netdev->priv;
-	int port_num = mp->port_num;
-	int autoneg = eth_port_autoneg_supported(port_num);
-	int mode_10_bit;
-	int auto_duplex;
-	int half_duplex = 0;
-	int full_duplex = 0;
-	int auto_speed;
-	int speed_10 = 0;
-	int speed_100 = 0;
-	int speed_1000 = 0;
-
-	u32 pcs = mv_read(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num));
-	u32 psr = mv_read(MV643XX_ETH_PORT_STATUS_REG(port_num));
-
-	mode_10_bit = psr & MV643XX_ETH_PORT_STATUS_MODE_10_BIT;
-
-	if (mode_10_bit) {
-		ecmd->supported = SUPPORTED_10baseT_Half;
-	} else {
-		ecmd->supported = (SUPPORTED_10baseT_Half		|
-				   SUPPORTED_10baseT_Full		|
-				   SUPPORTED_100baseT_Half		|
-				   SUPPORTED_100baseT_Full		|
-				   SUPPORTED_1000baseT_Full		|
-				   (autoneg ? SUPPORTED_Autoneg : 0)	|
-				   SUPPORTED_TP);
-
-		auto_duplex = !(pcs & MV643XX_ETH_DISABLE_AUTO_NEG_FOR_DUPLX);
-		auto_speed = !(pcs & MV643XX_ETH_DISABLE_AUTO_NEG_SPEED_GMII);
-
-		ecmd->advertising = ADVERTISED_TP;
-
-		if (autoneg) {
-			ecmd->advertising |= ADVERTISED_Autoneg;
-
-			if (auto_duplex) {
-				half_duplex = 1;
-				full_duplex = 1;
-			} else {
-				if (pcs & MV643XX_ETH_SET_FULL_DUPLEX_MODE)
-					full_duplex = 1;
-				else
-					half_duplex = 1;
-			}
-
-			if (auto_speed) {
-				speed_10 = 1;
-				speed_100 = 1;
-				speed_1000 = 1;
-			} else {
-				if (pcs & MV643XX_ETH_SET_GMII_SPEED_TO_1000)
-					speed_1000 = 1;
-				else if (pcs & MV643XX_ETH_SET_MII_SPEED_TO_100)
-					speed_100 = 1;
-				else
-					speed_10 = 1;
-			}
-
-			if (speed_10 & half_duplex)
-				ecmd->advertising |= ADVERTISED_10baseT_Half;
-			if (speed_10 & full_duplex)
-				ecmd->advertising |= ADVERTISED_10baseT_Full;
-			if (speed_100 & half_duplex)
-				ecmd->advertising |= ADVERTISED_100baseT_Half;
-			if (speed_100 & full_duplex)
-				ecmd->advertising |= ADVERTISED_100baseT_Full;
-			if (speed_1000)
-				ecmd->advertising |= ADVERTISED_1000baseT_Full;
-		}
-	}
+	int rc;
+	struct mv643xx_private *mp = netdev_priv(netdev);
 
-	ecmd->port = PORT_TP;
-	ecmd->phy_address = ethernet_phy_get(port_num);
-
-	ecmd->transceiver = XCVR_EXTERNAL;
-
-	if (netif_carrier_ok(netdev)) {
-		if (mode_10_bit)
-			ecmd->speed = SPEED_10;
-		else {
-			if (psr & MV643XX_ETH_PORT_STATUS_GMII_1000)
-				ecmd->speed = SPEED_1000;
-			else if (psr & MV643XX_ETH_PORT_STATUS_MII_100)
-				ecmd->speed = SPEED_100;
-			else
-				ecmd->speed = SPEED_10;
-		}
+	ecmd->supported = SUPPORTED_MII;
+	ecmd->port = PORT_MII;
+	rc = mii_ethtool_gset(&mp->mii, ecmd);
 
-		if (psr & MV643XX_ETH_PORT_STATUS_FULL_DUPLEX)
-			ecmd->duplex = DUPLEX_FULL;
-		else
-			ecmd->duplex = DUPLEX_HALF;
-	} else {
-		ecmd->speed = -1;
-		ecmd->duplex = -1;
-	}
+	ecmd->supported &= ~SUPPORTED_1000baseT_Half;
+	ecmd->advertising &= ~ADVERTISED_1000baseT_Half;
 
-	ecmd->autoneg = autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE;
-	return 0;
+	return rc;
 }
 
 static void

@@ -3059,15 +3085,54 @@
 	}
 }
 
+static u32 mv643xx_eth_get_msglevel(struct net_device *dev)
+{
+	struct mv643xx_private *mp = netdev_priv(dev);
+	return mp->msg_enable;
+}
+
+static void mv643xx_eth_set_msglevel(struct net_device *dev, u32 value)
+{
+	struct mv643xx_private *mp = netdev_priv(dev);
+	mp->msg_enable = value;
+}
+
+static u32 mv643xx_eth_get_link(struct net_device *dev)
+{
+	struct mv643xx_private *mp = netdev_priv(dev);
+	return mii_link_ok(&mp->mii);
+}
+
+static int mv643xx_eth_nway_restart(struct net_device *dev)
+{
+	struct mv643xx_private *mp = netdev_priv(dev);
+
+	return mii_nway_restart(&mp->mii);
+}
+
+static int mv643xx_eth_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
+{
+	struct mv643xx_private *mp = netdev_priv(dev);
+
+	return generic_mii_ioctl(&mp->mii, if_mii(ifr), cmd, NULL);
+}
+
 static struct ethtool_ops mv643xx_ethtool_ops = {
 	.get_settings           = mv643xx_get_settings,
+	.set_settings           = mv643xx_set_settings,
 	.get_drvinfo            = mv643xx_get_drvinfo,
-	.get_link               = ethtool_op_get_link,
+	.get_link               = mv643xx_eth_get_link,
 	.get_sg			= ethtool_op_get_sg,
 	.set_sg			= ethtool_op_set_sg,
 	.get_strings            = mv643xx_get_strings,
 	.get_stats_count        = mv643xx_get_stats_count,
 	.get_ethtool_stats      = mv643xx_get_ethtool_stats,
+	.get_strings            = mv643xx_get_strings,
+	.get_stats_count        = mv643xx_get_stats_count,
+	.get_ethtool_stats      = mv643xx_get_ethtool_stats,
+	.get_msglevel		= mv643xx_eth_get_msglevel,
+	.set_msglevel		= mv643xx_eth_set_msglevel,
+	.nway_reset		= mv643xx_eth_nway_restart,
 };
 
 /************* End ethtool support *************************/

183 lines not on this page · raw message

222 lines not on this page · raw message

Index: linux-2.5-enet/arch/ppc/platforms/katana.c
===================================================================
@@ -30,6 +30,7 @@
 #include <linux/bootmem.h>
 #include <linux/mtd/physmap.h>
 #include <linux/mv643xx.h>
+#include <linux/ethtool.h>
 #ifdef CONFIG_BOOTIMG
 #include <linux/bootimg.h>
 #endif

@@ -495,21 +496,30 @@
 #endif
 
 #if defined(CONFIG_MV643XX_ETH)
+static struct ethtool_cmd mv643xx_ethtool_cmd[] = {
+	[0] = {
+		.phy_address =	KATANA_ETH0_PHY_ADDR,
+		.autoneg =	AUTONEG_ENABLE,
+	},
+	[1] = {
+		.phy_address =	KATANA_ETH1_PHY_ADDR,
+		.autoneg =	AUTONEG_ENABLE,
+	},
+	[2] = {
+		.phy_address =	KATANA_ETH2_PHY_ADDR,
+		.autoneg =	AUTONEG_ENABLE,
+	}
+};
+
 static void __init
 katana_fixup_eth_pdata(struct platform_device *pdev)
 {
 	struct mv643xx_eth_platform_data *eth_pd;
-	static u16 phy_addr[] = {
-		KATANA_ETH0_PHY_ADDR,
-		KATANA_ETH1_PHY_ADDR,
-		KATANA_ETH2_PHY_ADDR,
-	};
 
 	eth_pd = pdev->dev.platform_data;
-	eth_pd->force_phy_addr = 1;
-	eth_pd->phy_addr = phy_addr[pdev->id];
 	eth_pd->tx_queue_size = KATANA_ETH_TX_QUEUE_SIZE;
 	eth_pd->rx_queue_size = KATANA_ETH_RX_QUEUE_SIZE;
+	eth_pd->ethtool_cmd = &mv643xx_ethtool_cmd[pdev->id];
 }
 #endif
 

Index: linux-2.6/arch/ppc/platforms/radstone_ppc7d.c
===================================================================
@@ -41,6 +41,7 @@
 #include <linux/serial_core.h>
 #include <linux/mv643xx.h>
 #include <linux/netdevice.h>
+#include <linux/ethtool.h>
 
 #include <asm/system.h>
 #include <asm/pgtable.h>

@@ -638,21 +639,30 @@
 #endif
 
 #if defined(CONFIG_MV643XX_ETH)
+static struct ethtool_cmd ppc7d_ethtool_cmd[] = {
+	[0] = {
+		.phy_address =	PPC7D_ETH0_PHY_ADDR,
+		.autoneg =	AUTONEG_ENABLE,
+	},
+	[1] = {
+		.phy_address =	PPC7D_ETH1_PHY_ADDR,
+		.autoneg =	AUTONEG_ENABLE,
+	},
+	[2] = {
+		.phy_address =	PPC7D_ETH2_PHY_ADDR,
+		.autoneg =	AUTONEG_ENABLE,
+	}
+};
+
 static void __init ppc7d_fixup_eth_pdata(struct platform_device *pdev)
 {
 	struct mv643xx_eth_platform_data *eth_pd;
-	static u16 phy_addr[] = {
-		PPC7D_ETH0_PHY_ADDR,
-		PPC7D_ETH1_PHY_ADDR,
-		PPC7D_ETH2_PHY_ADDR,
-	};
 	int i;
 
 	eth_pd = pdev->dev.platform_data;
-	eth_pd->force_phy_addr = 1;
-	eth_pd->phy_addr = phy_addr[pdev->id];
 	eth_pd->tx_queue_size = PPC7D_ETH_TX_QUEUE_SIZE;
 	eth_pd->rx_queue_size = PPC7D_ETH_RX_QUEUE_SIZE;
+	eth_pd->ethtool_cmd = &ppc7d_ethtool_cmd[pdev->id];
 
 	/* Adjust IRQ by mv64360_irq_base */
 	for (i = 0; i < pdev->num_resources; i++) {

@@ -665,7 +675,6 @@
 				 (int)r->start);
 		}
 	}
-
 }
 #endif
 

Index: linux-2.5-enet/drivers/net/mv643xx_eth.h
===================================================================
@@ -564,6 +564,7 @@
 
 	u32 msg_enable;
 	struct mii_if_info mii;
+	struct net_device *netdev;
 };
 
 /* ethernet.h API list */

@@ -582,12 +583,12 @@
 				 unsigned char *p_addr);
 
 /* PHY and MIB routines */
-static void ethernet_phy_reset(unsigned int eth_port_num);
+static void ethernet_phy_reset(struct mv643xx_private *mp);
 
-static void eth_port_write_smi_reg(unsigned int eth_port_num,
+static void eth_port_write_smi_reg(struct mv643xx_private *mp,
 				   unsigned int phy_reg, unsigned int value);
 
-static void eth_port_read_smi_reg(unsigned int eth_port_num,
+static void eth_port_read_smi_reg(struct mv643xx_private *mp,
 				  unsigned int phy_reg, unsigned int *value);
 
 static void eth_clear_mib_counters(unsigned int eth_port_num);

478 lines not on this page · raw message

Index: linux-2.5-enet/drivers/net/mv643xx_eth.h
===================================================================
@@ -75,6 +75,8 @@
 #define MV643XX_RX_COAL 100
 #endif
 
+#define MV643XX_PORT_MAX	3
+
 /*
  * The second part is the low level driver of the gigE ethernet ports.
  */

@@ -567,40 +569,4 @@
 	struct net_device *netdev;
 };
 
-/* ethernet.h API list */
-
-/* Port operation control routines */
-static void eth_port_init(struct mv643xx_private *mp);
-static void eth_port_reset(unsigned int eth_port_num);
-static void eth_port_start(struct mv643xx_private *mp);
-
-static void ethernet_set_config_reg(unsigned int eth_port_num,
-				    unsigned int value);
-static unsigned int ethernet_get_config_reg(unsigned int eth_port_num);
-
-/* Port MAC address routines */
-static void eth_port_uc_addr_set(unsigned int eth_port_num,
-				 unsigned char *p_addr);
-
-/* PHY and MIB routines */
-static void ethernet_phy_reset(struct mv643xx_private *mp);
-
-static void eth_port_write_smi_reg(struct mv643xx_private *mp,
-				   unsigned int phy_reg, unsigned int value);
-
-static void eth_port_read_smi_reg(struct mv643xx_private *mp,
-				  unsigned int phy_reg, unsigned int *value);
-
-static void eth_clear_mib_counters(unsigned int eth_port_num);
-
-/* Port data flow control routines */
-static ETH_FUNC_RET_STATUS eth_port_send(struct mv643xx_private *mp,
-					 struct pkt_info *p_pkt_info);
-static ETH_FUNC_RET_STATUS eth_tx_return_desc(struct mv643xx_private *mp,
-					      struct pkt_info *p_pkt_info);
-static ETH_FUNC_RET_STATUS eth_port_receive(struct mv643xx_private *mp,
-					    struct pkt_info *p_pkt_info);
-static ETH_FUNC_RET_STATUS eth_rx_return_buff(struct mv643xx_private *mp,
-					      struct pkt_info *p_pkt_info);
-
 #endif				/* __MV643XX_ETH_H__ */

Index: linux-2.5-enet/drivers/net/mv643xx_eth.c
===================================================================
@@ -92,6 +92,40 @@
 static int mv643xx_eth_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
 static struct ethtool_ops mv643xx_ethtool_ops;
 
+/* Port operation control routines */
+static void eth_port_init(struct mv643xx_private *mp);
+static void eth_port_reset(unsigned int eth_port_num);
+static void eth_port_start(struct mv643xx_private *mp);
+
+static void ethernet_set_config_reg(unsigned int eth_port_num,
+				    unsigned int value);
+static unsigned int ethernet_get_config_reg(unsigned int eth_port_num);
+
+/* Port MAC address routines */
+static void eth_port_uc_addr_set(unsigned int eth_port_num,
+				 unsigned char *p_addr);
+
+/* PHY and MIB routines */
+static void ethernet_phy_reset(struct mv643xx_private *mp);
+
+static void eth_port_write_smi_reg(struct mv643xx_private *mp,
+				   unsigned int phy_reg, unsigned int value);
+
+static void eth_port_read_smi_reg(struct mv643xx_private *mp,
+				  unsigned int phy_reg, unsigned int *value);
+
+static void eth_clear_mib_counters(unsigned int eth_port_num);
+
+/* Port data flow control routines */
+static ETH_FUNC_RET_STATUS eth_port_send(struct mv643xx_private *mp,
+					 struct pkt_info *p_pkt_info);
+static ETH_FUNC_RET_STATUS eth_tx_return_desc(struct mv643xx_private *mp,
+					      struct pkt_info *p_pkt_info);
+static ETH_FUNC_RET_STATUS eth_port_receive(struct mv643xx_private *mp,
+					    struct pkt_info *p_pkt_info);
+static ETH_FUNC_RET_STATUS eth_rx_return_buff(struct mv643xx_private *mp,
+					      struct pkt_info *p_pkt_info);
+
 static char mv643xx_driver_name[] = "mv643xx_eth";
 static char mv643xx_driver_version[] = "1.0";
 

@@ -1519,6 +1553,9 @@
 	int err;
 	struct ethtool_cmd *ecmd;
 
+	if (port_num >= MV643XX_PORT_MAX)
+		return -EINVAL;
+
 	dev = alloc_etherdev(sizeof(struct mv643xx_private));
 	if (!dev)
 		return -ENOMEM;

Index: linux-2.5-enet/drivers/net/mv643xx_eth.h
===================================================================
@@ -385,25 +385,6 @@
 #define ETH_TX_ENABLE_INTERRUPT			(BIT23)
 #define ETH_AUTO_MODE				(BIT30)
 
-/* typedefs */
-
-typedef enum _eth_func_ret_status {
-	ETH_OK,			/* Returned as expected.		*/
-	ETH_ERROR,		/* Fundamental error.			*/
-	ETH_RETRY,		/* Could not process request. Try later.*/
-	ETH_END_OF_JOB,		/* Ring has nothing to process.		*/
-	ETH_QUEUE_FULL,		/* Ring resource error.			*/
-	ETH_QUEUE_LAST_RESOURCE	/* Ring resources about to exhaust.	*/
-} ETH_FUNC_RET_STATUS;
-
-typedef enum _eth_target {
-	ETH_TARGET_DRAM,
-	ETH_TARGET_DEVICE,
-	ETH_TARGET_CBS,
-	ETH_TARGET_PCI0,
-	ETH_TARGET_PCI1
-} ETH_TARGET;
-
 /* These are for big-endian machines.  Little endian needs different
  * definitions.
  */

330 lines not on this page · raw message

Index: linux-2.5-enet/drivers/net/mv643xx_eth.c
===================================================================
@@ -80,50 +80,51 @@
 static int mv643xx_eth_real_stop(struct net_device *);
 static int mv643xx_eth_change_mtu(struct net_device *, int);
 static struct net_device_stats *mv643xx_eth_get_stats(struct net_device *);
-static void eth_port_init_mac_tables(unsigned int eth_port_num);
+static void eth_port_init_mac_tables(struct net_device *dev);
 #ifdef MV643XX_NAPI
 static int mv643xx_poll(struct net_device *dev, int *budget);
 #endif
-static int ethernet_phy_get(unsigned int eth_port_num);
-static void ethernet_phy_set(unsigned int eth_port_num, int phy_addr);
-static int ethernet_phy_detect(struct mv643xx_private *mp);
+static int ethernet_phy_get(struct net_device *dev);
+static void ethernet_phy_set(struct net_device *dev, int phy_addr);
+static void ethernet_phy_reset(struct net_device *dev);
+static int ethernet_phy_detect(struct net_device *dev);
 static int mv643xx_mdio_read(struct net_device *dev, int phy_id, int location);
 static void mv643xx_mdio_write(struct net_device *dev, int phy_id, int location, int val);
 static int mv643xx_eth_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
 static struct ethtool_ops mv643xx_ethtool_ops;
 
 /* Port operation control routines */
-static void eth_port_init(struct mv643xx_private *mp);
-static void eth_port_reset(unsigned int eth_port_num);
-static void eth_port_start(struct mv643xx_private *mp);
+static void eth_port_init(struct net_device *dev);
+static void eth_port_reset(struct net_device *dev);
+static void eth_port_start(struct net_device *dev);
 
-static void ethernet_set_config_reg(unsigned int eth_port_num,
+static void ethernet_set_config_reg(struct net_device *dev,
 				    unsigned int value);
-static unsigned int ethernet_get_config_reg(unsigned int eth_port_num);
+static unsigned int ethernet_get_config_reg(struct net_device *dev);
 
 /* Port MAC address routines */
-static void eth_port_uc_addr_set(unsigned int eth_port_num,
+static void eth_port_uc_addr_set(struct net_device *dev,
 				 unsigned char *p_addr);
 
 /* PHY and MIB routines */
-static void ethernet_phy_reset(struct mv643xx_private *mp);
+static void ethernet_phy_reset(struct net_device *dev);
 
-static void eth_port_write_smi_reg(struct mv643xx_private *mp,
+static void eth_port_write_smi_reg(struct net_device *dev,
 				   unsigned int phy_reg, unsigned int value);
 
-static void eth_port_read_smi_reg(struct mv643xx_private *mp,
+static void eth_port_read_smi_reg(struct net_device *dev,
 				  unsigned int phy_reg, unsigned int *value);
 
-static void eth_clear_mib_counters(unsigned int eth_port_num);
+static void eth_clear_mib_counters(struct net_device *dev);
 
 /* Port data flow control routines */
-static int eth_port_send(struct mv643xx_private *mp,
+static int eth_port_send(struct net_device *dev,
 			 struct pkt_info *p_pkt_info);
-static int eth_tx_return_desc(struct mv643xx_private *mp,
+static int eth_tx_return_desc(struct net_device *dev,
 			      struct pkt_info *p_pkt_info);
-static int eth_port_receive(struct mv643xx_private *mp,
+static int eth_port_receive(struct net_device *dev,
 			    struct pkt_info *p_pkt_info);
-static void eth_rx_return_buff(struct mv643xx_private *mp,
+static void eth_rx_return_buff(struct net_device *dev,
 			       struct pkt_info *p_pkt_info);
 
 static char mv643xx_driver_name[] = "mv643xx_eth";

@@ -220,7 +221,7 @@
 		pkt_info.buf_ptr = dma_map_single(NULL, skb->data, RX_SKB_SIZE,
 							DMA_FROM_DEVICE);
 		pkt_info.return_info = skb;
-		eth_rx_return_buff(mp, &pkt_info);
+		eth_rx_return_buff(dev, &pkt_info);
 		skb_reserve(skb, 2);
 	}
 	clear_bit(0, &mp->rx_task_busy);

@@ -275,11 +276,10 @@
 static void mv643xx_eth_update_mac_address(struct net_device *dev)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
-	unsigned int port_num = mp->port_num;
 
-	eth_port_init_mac_tables(port_num);
+	eth_port_init_mac_tables(dev);
 	memcpy(mp->port_mac_addr, dev->dev_addr, 6);
-	eth_port_uc_addr_set(port_num, mp->port_mac_addr);
+	eth_port_uc_addr_set(dev, mp->port_mac_addr);
 }
 
 /*

@@ -292,15 +292,14 @@
  */
 static void mv643xx_eth_set_rx_mode(struct net_device *dev)
 {
-	struct mv643xx_private *mp = netdev_priv(dev);
 	u32 config_reg;
 
-	config_reg = ethernet_get_config_reg(mp->port_num);
+	config_reg = ethernet_get_config_reg(dev);
 	if (dev->flags & IFF_PROMISC)
 		config_reg |= (u32) MV643XX_ETH_UNICAST_PROMISCUOUS_MODE;
 	else
 		config_reg &= ~(u32) MV643XX_ETH_UNICAST_PROMISCUOUS_MODE;
-	ethernet_set_config_reg(mp->port_num, config_reg);
+	ethernet_set_config_reg(dev, config_reg);
 }
 
 /*

@@ -351,11 +350,9 @@
  */
 static void mv643xx_eth_tx_timeout_task(struct net_device *dev)
 {
-	struct mv643xx_private *mp = netdev_priv(dev);
-
 	netif_device_detach(dev);
-	eth_port_reset(mp->port_num);
-	eth_port_start(mp);
+	eth_port_reset(dev);
+	eth_port_start(dev);
 	netif_device_attach(dev);
 }
 

@@ -380,7 +377,7 @@
 	spin_lock(&mp->lock);
 
 	/* Check only queue 0 */
-	while (eth_tx_return_desc(mp, &pkt_info) == 0) {
+	while (eth_tx_return_desc(dev, &pkt_info) == 0) {
 		if (pkt_info.cmd_sts & BIT0) {
 			if (netif_msg_tx_err(mp))
 				printk(KERN_WARNING "%s: Error in TX: cmd_sts=%08x\n",

@@ -449,9 +446,9 @@
 	struct pkt_info pkt_info;
 
 #ifdef MV643XX_NAPI
-	while (eth_port_receive(mp, &pkt_info) == 0 && budget > 0) {
+	while (eth_port_receive(dev, &pkt_info) == 0 && budget > 0) {
 #else
-	while (eth_port_receive(mp, &pkt_info) == 0) {
+	while (eth_port_receive(dev, &pkt_info) == 0) {
 #endif
 		mp->rx_ring_skbs--;
 		received_packets++;

@@ -829,7 +826,6 @@
 static int mv643xx_eth_open(struct net_device *dev)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
-	unsigned int port_num = mp->port_num;
 	int err;
 
 	spin_lock_irq(&mp->lock);

@@ -838,8 +834,8 @@
 			SA_SHIRQ | SA_SAMPLE_RANDOM, dev->name, dev);
 
 	if (err) {
-		printk(KERN_ERR "Can not assign IRQ number to MV643XX_eth%d\n",
-								port_num);
+		printk(KERN_ERR "%s: Cannot assign IRQ number\n",
+		       dev->name);
 		err = -EAGAIN;
 		goto out;
 	}

@@ -879,7 +875,7 @@
  *	with physical addresses.
  *
  * INPUT:
- *	struct mv643xx_private *mp	Ethernet Port Control srtuct.
+ *	struct net_device *dev	Ethernet Port Control srtuct.
  *
  * OUTPUT:
  *	The routine updates the Ethernet port control struct with information

@@ -888,8 +884,9 @@
  * RETURN:
  *	None.
  */
-static void ether_init_rx_desc_ring(struct mv643xx_private *mp)
+static void ether_init_rx_desc_ring(struct net_device *dev)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
 	volatile struct eth_rx_desc *p_rx_desc;
 	int rx_desc_num = mp->rx_ring_size;
 	int i;

@@ -924,7 +921,7 @@
  *	with physical addresses.
  *
  * INPUT:
- *	struct mv643xx_private *mp	Ethernet Port Control srtuct.
+ *	struct net_device *dev	Ethernet Port Control srtuct.
  *
  * OUTPUT:
  *	The routine updates the Ethernet port control struct with information

@@ -933,8 +930,9 @@
  * RETURN:
  *	None.
  */
-static void ether_init_tx_desc_ring(struct mv643xx_private *mp)
+static void ether_init_tx_desc_ring(struct net_device *dev)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
 	int tx_desc_num = mp->tx_ring_size;
 	struct eth_tx_desc *p_tx_desc;
 	int i;

@@ -983,7 +981,7 @@
 	/* Set the MAC Address */
 	memcpy(mp->port_mac_addr, dev->dev_addr, 6);
 
-	eth_port_init(mp);
+	eth_port_init(dev);
 
 	INIT_WORK(&mp->rx_task, (void (*)(void *))mv643xx_eth_rx_task, dev);
 

@@ -1033,7 +1031,7 @@
 	BUG_ON((u32) mp->p_tx_desc_area & 0xf);	/* check 16-byte alignment */
 	memset((void *)mp->p_tx_desc_area, 0, mp->tx_desc_area_size);
 
-	ether_init_tx_desc_ring(mp);
+	ether_init_tx_desc_ring(dev);
 
 	/* Allocate RX ring */
 	mp->rx_ring_skbs = 0;

@@ -1063,11 +1061,11 @@
 	}
 	memset((void *)mp->p_rx_desc_area, 0, size);
 
-	ether_init_rx_desc_ring(mp);
+	ether_init_rx_desc_ring(dev);
 
 	mv643xx_eth_rx_task(dev);	/* Fill RX ring with skb's */
 
-	eth_port_start(mp);
+	eth_port_start(dev);
 
 	/* Interrupt Coalescing */
 

@@ -1087,11 +1085,10 @@
 static void mv643xx_eth_free_tx_rings(struct net_device *dev)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
-	unsigned int port_num = mp->port_num;
 	unsigned int curr;
 
 	/* Stop Tx Queues */
-	mv_write(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(port_num), 0x0000ff00);
+	mv_write(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(mp->port_num), 0x0000ff00);
 
 	/* Free outstanding skb's on TX rings */
 	for (curr = 0; mp->tx_ring_skbs && curr < mp->tx_ring_size; curr++) {

@@ -1115,11 +1112,10 @@
 static void mv643xx_eth_free_rx_rings(struct net_device *dev)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
-	unsigned int port_num = mp->port_num;
 	int curr;
 
 	/* Stop RX Queues */
-	mv_write(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(port_num), 0x0000ff00);
+	mv_write(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(mp->port_num), 0x0000ff00);
 
 	/* Free preallocated skb's on RX rings */
 	for (curr = 0; mp->rx_ring_skbs && curr < mp->rx_ring_size; curr++) {

@@ -1165,7 +1161,7 @@
 	mv643xx_eth_free_tx_rings(dev);
 	mv643xx_eth_free_rx_rings(dev);
 
-	eth_port_reset(mp->port_num);
+	eth_port_reset(dev);
 
 	/* Disable ethernet port interrupts */
 	mv_write(MV643XX_ETH_INTERRUPT_CAUSE_REG(port_num), 0);

@@ -1200,7 +1196,7 @@
 	struct mv643xx_private *mp = netdev_priv(dev);
 	struct pkt_info pkt_info;
 
-	while (eth_tx_return_desc(mp, &pkt_info) == 0) {
+	while (eth_tx_return_desc(dev, &pkt_info) == 0) {
 		if (pkt_info.return_info) {
 			if (skb_shinfo(pkt_info.return_info)->nr_frags)
 				dma_unmap_page(NULL, pkt_info.buf_ptr,

@@ -1351,7 +1347,7 @@
 							DMA_TO_DEVICE);
 		pkt_info.return_info = skb;
 		mp->tx_ring_skbs++;
-		status = eth_port_send(mp, &pkt_info);
+		status = eth_port_send(dev, &pkt_info);
 		if (status < 0)
 			goto out;
 

@@ -1409,7 +1405,7 @@
 			}
 		}
 
-		status = eth_port_send(mp, &pkt_info);
+		status = eth_port_send(dev, &pkt_info);
 		if (status < 0)
 			goto out;
 

@@ -1438,7 +1434,7 @@
 							this_frag->size,
 							DMA_TO_DEVICE);
 
-			status = eth_port_send(mp, &pkt_info);
+			status = eth_port_send(dev, &pkt_info);
 			if (status < 0)
 				goto out;
 

@@ -1454,8 +1450,8 @@
 								DMA_TO_DEVICE);
 	pkt_info.return_info = skb;
 	mp->tx_ring_skbs++;
-	status = eth_port_send(mp, &pkt_info);
-	if (status == 0)
+	status = eth_port_send(dev, &pkt_info);
+	if (status < 0)
 		goto out;
 
 	stats->tx_bytes += pkt_info.byte_cnt;

@@ -1532,7 +1528,6 @@
 	dev_set_drvdata(ddev, dev);
 
 	mp = netdev_priv(dev);
-	mp->netdev = dev;
 
 	/* By default, log probe, interface up/down and error events */
 	mp->msg_enable = NETIF_MSG_PROBE | NETIF_MSG_IFUP | NETIF_MSG_IFDOWN |

@@ -1624,7 +1619,7 @@
 						    ADVERTISED_Autoneg	      |
 						    ADVERTISED_MII;
 
-			ethernet_phy_set(port_num, ecmd->phy_address);
+			ethernet_phy_set(dev, ecmd->phy_address);
 			memcpy(&mp->ethtool_cmd, ecmd, sizeof *ecmd);
 			mv643xx_eth_update_pscr(dev, ecmd);
 		}

@@ -1634,15 +1629,15 @@
 	mp->mii.dev = dev;
 	mp->mii.mdio_read = mv643xx_mdio_read;
 	mp->mii.mdio_write = mv643xx_mdio_write;
-	mp->mii.phy_id = ethernet_phy_get(port_num);
+	mp->mii.phy_id = ethernet_phy_get(dev);
 	mp->mii.phy_id_mask = 0x3f;
 	mp->mii.reg_num_mask = 0x1f;
 
-	err = ethernet_phy_detect(mp);
+	err = ethernet_phy_detect(dev);
 	if (err) {
 		printk(KERN_ERR "MV643xx ethernet port %d: "
 		       "No PHY detected at addr %d\n",
-		       port_num, ethernet_phy_get(port_num));
+		       port_num, ethernet_phy_get(dev));
 		return err;
 	}
 

@@ -1939,10 +1934,6 @@
 
 /* locals */
 
-/* PHY routines */
-static int ethernet_phy_get(unsigned int eth_port_num);
-static void ethernet_phy_set(unsigned int eth_port_num, int phy_addr);
-
 /* Ethernet Port routines */
 static int eth_port_uc_addr(unsigned int eth_port_num, unsigned char uc_nibble,
 								int option);

@@ -1963,7 +1954,7 @@
  *	struct.
  *
  * INPUT:
- *	struct mv643xx_private *mp	Ethernet port control struct
+ *	struct net_device *dev	Ethernet port control struct
  *
  * OUTPUT:
  *	See description.

@@ -1971,19 +1962,21 @@
  * RETURN:
  *	None.
  */
-static void eth_port_init(struct mv643xx_private *mp)
+static void eth_port_init(struct net_device *dev)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
+
 	mp->port_rx_queue_command = 0;
 	mp->port_tx_queue_command = 0;
 
 	mp->rx_resource_err = 0;
 	mp->tx_resource_err = 0;
 
-	eth_port_reset(mp->port_num);
+	eth_port_reset(dev);
 
-	eth_port_init_mac_tables(mp->port_num);
+	eth_port_init_mac_tables(dev);
 
-	ethernet_phy_reset(mp);
+	ethernet_phy_reset(dev);
 }
 
 /*

@@ -2005,7 +1998,7 @@
  *	and ether_init_rx_desc_ring for Rx queues).
  *
  * INPUT:
- *	struct mv643xx_private *mp	Ethernet port control struct
+ *	struct net_device *dev	Ethernet port control struct
  *
  * OUTPUT:
  *	Ethernet port is ready to receive and transmit.

@@ -2013,8 +2006,9 @@
  * RETURN:
  *	None.
  */
-static void eth_port_start(struct mv643xx_private *mp)
+static void eth_port_start(struct net_device *dev)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
 	unsigned int port_num = mp->port_num;
 	int tx_curr_desc, rx_curr_desc;
 

@@ -2029,7 +2023,7 @@
 		(u32)((struct eth_rx_desc *)mp->rx_desc_dma + rx_curr_desc));
 
 	/* Add the assigned Ethernet address to the port's address table */
-	eth_port_uc_addr_set(port_num, mp->port_mac_addr);
+	eth_port_uc_addr_set(dev, mp->port_mac_addr);
 
 	/* Assign port configuration and command. */
 	mv_write(MV643XX_ETH_PORT_CONFIG_REG(port_num),

@@ -2082,9 +2076,11 @@
  *	N/A.
  *
  */
-static void eth_port_uc_addr_set(unsigned int eth_port_num,
-							unsigned char *p_addr)
+static void eth_port_uc_addr_set(struct net_device *dev,
+				 unsigned char *p_addr)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
+	unsigned int eth_port_num = mp->port_num;
 	unsigned int mac_h;
 	unsigned int mac_l;
 

@@ -2218,9 +2214,11 @@
  * RETURN:
  *	None.
  */
-static void eth_port_init_mac_tables(unsigned int eth_port_num)
+static void eth_port_init_mac_tables(struct net_device *dev)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
 	int table_index;
+	unsigned int eth_port_num = mp->port_num;
 
 	/* Clear DA filter unicast table (Ex_dFUT) */
 	for (table_index = 0; table_index <= 0xC; table_index += 4)

@@ -2254,8 +2252,10 @@
  *	MIB counter value.
  *
  */
-static void eth_clear_mib_counters(unsigned int eth_port_num)
+static void eth_clear_mib_counters(struct net_device *dev)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
+	unsigned int eth_port_num = mp->port_num;
 	int i;
 
 	/* Perform dummy reads from MIB counters */

@@ -2264,34 +2264,37 @@
 		mv_read(MV643XX_ETH_MIB_COUNTERS_BASE(eth_port_num) + i);
 }
 
-static inline u32 read_mib(struct mv643xx_private *mp, int offset)
+static inline u32 read_mib(struct net_device *dev, int offset)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
+
 	return mv_read(MV643XX_ETH_MIB_COUNTERS_BASE(mp->port_num) + offset);
 }
 
-static void eth_update_mib_counters(struct mv643xx_private *mp)
+static void eth_update_mib_counters(struct net_device *dev)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
 	struct mv643xx_mib_counters *p = &mp->mib_counters;
 	int offset;
 
 	p->good_octets_received +=
-		read_mib(mp, ETH_MIB_GOOD_OCTETS_RECEIVED_LOW);
+		read_mib(dev, ETH_MIB_GOOD_OCTETS_RECEIVED_LOW);
 	p->good_octets_received +=
-		(u64)read_mib(mp, ETH_MIB_GOOD_OCTETS_RECEIVED_HIGH) << 32;
+		(u64)read_mib(dev, ETH_MIB_GOOD_OCTETS_RECEIVED_HIGH) << 32;
 
 	for (offset = ETH_MIB_BAD_OCTETS_RECEIVED;
 			offset <= ETH_MIB_FRAMES_1024_TO_MAX_OCTETS;
 			offset += 4)
-		*(u32 *)((char *)p + offset) = read_mib(mp, offset);
+		*(u32 *)((char *)p + offset) = read_mib(dev, offset);
 
-	p->good_octets_sent += read_mib(mp, ETH_MIB_GOOD_OCTETS_SENT_LOW);
+	p->good_octets_sent += read_mib(dev, ETH_MIB_GOOD_OCTETS_SENT_LOW);
 	p->good_octets_sent +=
-		(u64)read_mib(mp, ETH_MIB_GOOD_OCTETS_SENT_HIGH) << 32;
+		(u64)read_mib(dev, ETH_MIB_GOOD_OCTETS_SENT_HIGH) << 32;
 
 	for (offset = ETH_MIB_GOOD_FRAMES_SENT;
 			offset <= ETH_MIB_LATE_COLLISION;
 			offset += 4)
-		*(u32 *)((char *)p + offset) = read_mib(mp, offset);
+		*(u32 *)((char *)p + offset) = read_mib(dev, offset);
 }
 
 /*

@@ -2312,22 +2315,22 @@
  *	-ENODEV on failure
  *
  */
-static int ethernet_phy_detect(struct mv643xx_private *mp)
+static int ethernet_phy_detect(struct net_device *dev)
 {
 	unsigned int phy_reg_data0;
 	int auto_neg;
 
-	eth_port_read_smi_reg(mp, 0, &phy_reg_data0);
+	eth_port_read_smi_reg(dev, 0, &phy_reg_data0);
 	auto_neg = phy_reg_data0 & 0x1000;
 	phy_reg_data0 ^= 0x1000;	/* invert auto_neg */
-	eth_port_write_smi_reg(mp, 0, phy_reg_data0);
+	eth_port_write_smi_reg(dev, 0, phy_reg_data0);
 
-	eth_port_read_smi_reg(mp, 0, &phy_reg_data0);
+	eth_port_read_smi_reg(dev, 0, &phy_reg_data0);
 	if ((phy_reg_data0 & 0x1000) == auto_neg)
 		return -ENODEV;				/* change didn't take */
 
 	phy_reg_data0 ^= 0x1000;
-	eth_port_write_smi_reg(mp, 0, phy_reg_data0);
+	eth_port_write_smi_reg(dev, 0, phy_reg_data0);
 	return 0;
 }
 

@@ -2347,13 +2350,14 @@
  *	PHY address.
  *
  */
-static int ethernet_phy_get(unsigned int eth_port_num)
+static int ethernet_phy_get(struct net_device *dev)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
 	unsigned int reg_data;
 
 	reg_data = mv_read(MV643XX_ETH_PHY_ADDR_REG);
 
-	return ((reg_data >> (5 * eth_port_num)) & 0x1f);
+	return ((reg_data >> (5 * mp->port_num)) & 0x1f);
 }
 
 /*

@@ -2373,10 +2377,11 @@
  *	None.
  *
  */
-static void ethernet_phy_set(unsigned int eth_port_num, int phy_addr)
+static void ethernet_phy_set(struct net_device *dev, int phy_addr)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
 	u32 reg_data;
-	int addr_shift = 5 * eth_port_num;
+	int addr_shift = 5 * mp->port_num;
 
 	reg_data = mv_read(MV643XX_ETH_PHY_ADDR_REG);
 	reg_data &= ~(0x1f << addr_shift);

@@ -2400,14 +2405,14 @@
  *	None.
  *
  */
-static void ethernet_phy_reset(struct mv643xx_private *mp)
+static void ethernet_phy_reset(struct net_device *dev)
 {
 	unsigned int phy_reg_data;
 
 	/* Reset the PHY */
-	eth_port_read_smi_reg(mp, 0, &phy_reg_data);
+	eth_port_read_smi_reg(dev, 0, &phy_reg_data);
 	phy_reg_data |= 0x8000;	/* Set bit 15 to reset the PHY */
-	eth_port_write_smi_reg(mp, 0, phy_reg_data);
+	eth_port_write_smi_reg(dev, 0, phy_reg_data);
 }
 
 /*

@@ -2428,8 +2433,10 @@
  *	None.
  *
  */
-static void eth_port_reset(unsigned int port_num)
+static void eth_port_reset(struct net_device *dev)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
+	unsigned int port_num = mp->port_num;
 	unsigned int reg_data;
 
 	/* Stop Tx port activity. Check port Tx activity. */

@@ -2463,7 +2470,7 @@
 	}
 
 	/* Clear all MIB counters */
-	eth_clear_mib_counters(port_num);
+	eth_clear_mib_counters(dev);
 
 	/* Reset the Enable bit in the Configuration Register */
 	reg_data = mv_read(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num));

@@ -2490,9 +2497,11 @@
  *	None.
  *
  */
-static void ethernet_set_config_reg(unsigned int eth_port_num,
-							unsigned int value)
+static void ethernet_set_config_reg(struct net_device *dev,
+				    unsigned int value)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
+	unsigned int eth_port_num = mp->port_num;
 	unsigned int eth_config_reg;
 
 	eth_config_reg = mv_read(MV643XX_ETH_PORT_CONFIG_REG(eth_port_num));

@@ -2516,12 +2525,13 @@
  * RETURN:
  *	Port configuration register value.
  */
-static unsigned int ethernet_get_config_reg(unsigned int eth_port_num)
+static unsigned int ethernet_get_config_reg(struct net_device *dev)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
 	unsigned int eth_config_reg;
 
 	eth_config_reg = mv_read(MV643XX_ETH_PORT_CONFIG_EXTEND_REG
-								(eth_port_num));
+								(mp->port_num));
 	return eth_config_reg;
 }
 

@@ -2545,11 +2555,10 @@
  *	true otherwise.
  *
  */
-static void eth_port_read_smi_reg(struct mv643xx_private *mp,
+static void eth_port_read_smi_reg(struct net_device *dev,
 				unsigned int phy_reg, unsigned int *value)
 {
-	unsigned int port_num = mp->port_num;
-	int phy_addr = ethernet_phy_get(port_num);
+	int phy_addr = ethernet_phy_get(dev);
 	unsigned long flags;
 	int i;
 

@@ -2560,7 +2569,7 @@
 	for (i = 0; mv_read(MV643XX_ETH_SMI_REG) & ETH_SMI_BUSY; i++) {
 		if (i == PHY_WAIT_ITERATIONS) {
 			printk(KERN_ERR "%s: PHY busy timeout\n", 
-			       mp->netdev->name);
+			       dev->name);
 			goto out;
 		}
 		udelay(PHY_WAIT_MICRO_SECONDS);

@@ -2573,7 +2582,7 @@
 	for (i = 0; !(mv_read(MV643XX_ETH_SMI_REG) & ETH_SMI_READ_VALID); i++) {
 		if (i == PHY_WAIT_ITERATIONS) {
 			printk(KERN_ERR "%s: PHY read timeout\n",
-			       mp->netdev->name);
+			       dev->name);
 			goto out;
 		}
 		udelay(PHY_WAIT_MICRO_SECONDS);

@@ -2604,15 +2613,14 @@
  *	true otherwise.
  *
  */
-static void eth_port_write_smi_reg(struct mv643xx_private *mp,
+static void eth_port_write_smi_reg(struct net_device *dev,
 				   unsigned int phy_reg, unsigned int value)
 {
 	int phy_addr;
 	int i;
 	unsigned long flags;
-	unsigned int eth_port_num = mp->port_num;
 
-	phy_addr = ethernet_phy_get(eth_port_num);
+	phy_addr = ethernet_phy_get(dev);
 
 	/* the SMI register is a shared resource */
 	spin_lock_irqsave(&mv643xx_eth_phy_lock, flags);

@@ -2621,7 +2629,7 @@
 	for (i = 0; mv_read(MV643XX_ETH_SMI_REG) & ETH_SMI_BUSY; i++) {
 		if (i == PHY_WAIT_ITERATIONS) {
 			printk(KERN_ERR "%s: PHY busy timeout\n", 
-			       mp->netdev->name);
+			       dev->name);
 			goto out;
 		}
 		udelay(PHY_WAIT_MICRO_SECONDS);

@@ -2639,16 +2647,14 @@
 static int mv643xx_mdio_read(struct net_device *dev, int phy_id, int location)
 {
 	int val;
-	struct mv643xx_private *mp = netdev_priv(dev);
 
-	eth_port_read_smi_reg(mp, location, &val);
+	eth_port_read_smi_reg(dev, location, &val);
 	return val;
 }
 
 static void mv643xx_mdio_write(struct net_device *dev, int phy_id, int location, int val)
 {
-	struct mv643xx_private *mp = netdev_priv(dev);
-	eth_port_write_smi_reg(mp, location, val);
+	eth_port_write_smi_reg(dev, location, val);
 }
 
 /*

@@ -2682,7 +2688,7 @@
 /*
  * Modified to include the first descriptor pointer in case of SG
  */
-static int eth_port_send(struct mv643xx_private *mp,
+static int eth_port_send(struct net_device *dev,
 			 struct pkt_info *p_pkt_info)
 {
 	int tx_desc_curr, tx_desc_used, tx_first_desc, tx_next_desc;

@@ -2774,9 +2780,10 @@
 	return status;
 }
 #else
-static int eth_port_send(struct mv643xx_private *mp,
+static int eth_port_send(struct net_device *dev,
 			 struct pkt_info *p_pkt_info)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
 	int tx_desc_curr;
 	int tx_desc_used;
 	struct eth_tx_desc *current_descriptor;

@@ -2801,7 +2808,7 @@
 
 	if (netif_msg_tx_queued(mp))
 		printk(KERN_DEBUG "%s: send pkt: desc=%d len=%d, f/l=%d/%d\n",
-		       mp->netdev->name, tx_desc_curr,
+		       dev->name, tx_desc_curr,
 		       p_pkt_info->byte_cnt, 
 		       ((command_status & ETH_TX_FIRST_DESC) != 0),
 		       ((command_status & ETH_TX_LAST_DESC) != 0));

@@ -2831,7 +2838,7 @@
 
 out:
 	if (status == -ENOBUFS)
-		printk(KERN_ERR "%s: Error on Queue Full\n", mp->netdev->name);
+		printk(KERN_ERR "%s: Error on Queue Full\n", dev->name);
 
 	return status;
 }

@@ -2861,9 +2868,10 @@
  *	ETH_OK otherwise.
  *
  */
-static int eth_tx_return_desc(struct mv643xx_private *mp,
+static int eth_tx_return_desc(struct net_device *dev,
 			      struct pkt_info *p_pkt_info)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
 	int tx_desc_used;
 #ifdef MV643XX_CHECKSUM_OFFLOAD_TX
 	int tx_busy_desc = mp->tx_first_desc_q;

@@ -2929,9 +2937,10 @@
  *	ETH_END_OF_JOB if there is no received data.
  *	ETH_OK otherwise.
  */
-static int eth_port_receive(struct mv643xx_private *mp,
+static int eth_port_receive(struct net_device *dev,
 						struct pkt_info *p_pkt_info)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
 	int rx_next_curr_desc, rx_curr_desc, rx_used_desc;
 	volatile struct eth_rx_desc *p_rx_desc;
 	unsigned int command_status;

@@ -2962,7 +2971,7 @@
 
 	if (netif_msg_rx_status(mp))
 		printk(KERN_DEBUG "%s: rcv pkt: len=%d, desc=%d, f/l=%d/%d\n",
-		       mp->netdev->name, 
+		       dev->name, 
 		       p_pkt_info->byte_cnt, rx_curr_desc,
 		       ((command_status & ETH_RX_FIRST_DESC) != 0),
 		       ((command_status & ETH_RX_LAST_DESC) != 0));

@@ -3002,9 +3011,10 @@
  *	ETH_ERROR in case the routine can not access Rx desc ring.
  *	ETH_OK otherwise.
  */
-static void eth_rx_return_buff(struct mv643xx_private *mp,
+static void eth_rx_return_buff(struct net_device *dev,
 			       struct pkt_info *p_pkt_info)
 {
+	struct mv643xx_private *mp = netdev_priv(dev);
 	int used_rx_desc;	/* Where to return Rx resource */
 	volatile struct eth_rx_desc *p_used_rx_desc;
 

@@ -3018,7 +3028,7 @@
 
 	if (netif_msg_rx_status(mp))
 		printk(KERN_DEBUG "%s: rx done, len=%d, desc=%d, status=%08x\n",
-		       mp->netdev->name, p_pkt_info->byte_cnt, used_rx_desc,
+		       dev->name, p_pkt_info->byte_cnt, used_rx_desc,
 		       p_used_rx_desc->cmd_sts);
 
 	/* Flush the write pipe */

@@ -3131,7 +3141,7 @@
 	struct mv643xx_private *mp = netdev->priv;
 	int i;
 
-	eth_update_mib_counters(mp);
+	eth_update_mib_counters(netdev);
 
 	for(i = 0; i < MV643XX_STATS_LEN; i++) {
 		char *p = (char *)mp+mv643xx_gstrings_stats[i].stat_offset;	

Index: linux-2.5-enet/drivers/net/mv643xx_eth.h
===================================================================
@@ -547,7 +547,6 @@
 
 	u32 msg_enable;
 	struct mii_if_info mii;
-	struct net_device *netdev;
 };
 
 #endif				/* __MV643XX_ETH_H__ */

Index: linux-2.5-enet/drivers/net/mv643xx_eth.c
===================================================================
@@ -561,9 +561,10 @@
 								(port_num), 0);
 			__netif_rx_schedule(dev);
 		}
+	}
 #else
 		if (eth_int_cause & (BIT2 | BIT11))
-			mv643xx_eth_receive_queue(dev, 0);
+			mv643xx_eth_receive_queue(dev);
 
 		/*
 		 * After forwarded received packets to upper layer, add a task

@@ -580,7 +581,6 @@
 		mp->rx_task.func(dev);
 #endif
 #endif
-	}
 	/* PHY status changed */
 	if (eth_int_cause_ext & (BIT16 | BIT20)) {
 		struct ethtool_cmd cmd;

Index: linux-2.5-enet/drivers/net/mv643xx_eth.c
===================================================================
@@ -74,57 +74,56 @@
 #define PHY_WAIT_MICRO_SECONDS	10
 
 /* Static function declarations */
-static void eth_port_uc_addr_get(struct net_device *dev,
-						unsigned char *MacAddr);
 static int mv643xx_eth_real_open(struct net_device *);
 static int mv643xx_eth_real_stop(struct net_device *);
 static int mv643xx_eth_change_mtu(struct net_device *, int);
 static struct net_device_stats *mv643xx_eth_get_stats(struct net_device *);
-static void eth_port_init_mac_tables(struct net_device *dev);
+static void mv643xx_eth_port_init_mac_tables(struct net_device *dev);
 #ifdef MV643XX_NAPI
-static int mv643xx_poll(struct net_device *dev, int *budget);
+static int mv643xx_eth_poll(struct net_device *dev, int *budget);
 #endif
-static int ethernet_phy_get(struct net_device *dev);
-static void ethernet_phy_set(struct net_device *dev, int phy_addr);
-static void ethernet_phy_reset(struct net_device *dev);
-static int ethernet_phy_detect(struct net_device *dev);
-static int mv643xx_mdio_read(struct net_device *dev, int phy_id, int location);
-static void mv643xx_mdio_write(struct net_device *dev, int phy_id, int location, int val);
+static int mv643xx_eth_phy_get(struct net_device *dev);
+static void mv643xx_eth_phy_set(struct net_device *dev, int phy_addr);
+static void mv643xx_eth_phy_reset(struct net_device *dev);
+static int mv643xx_eth_phy_detect(struct net_device *dev);
+static int mv643xx_eth_mdio_read(struct net_device *dev, int phy_id, int location);
+static void mv643xx_eth_mdio_write(struct net_device *dev, int phy_id, int location, int val);
 static int mv643xx_eth_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
 static struct ethtool_ops mv643xx_ethtool_ops;
 
 /* Port operation control routines */
-static void eth_port_init(struct net_device *dev);
-static void eth_port_reset(struct net_device *dev);
-static void eth_port_start(struct net_device *dev);
+static void mv643xx_eth_port_init(struct net_device *dev);
+static void mv643xx_eth_port_reset(struct net_device *dev);
+static void mv643xx_eth_port_start(struct net_device *dev);
 
-static void ethernet_set_config_reg(struct net_device *dev,
+static void mv643xx_eth_set_config_reg(struct net_device *dev,
 				    unsigned int value);
-static unsigned int ethernet_get_config_reg(struct net_device *dev);
+static unsigned int mv643xx_eth_get_config_reg(struct net_device *dev);
 
 /* Port MAC address routines */
-static void eth_port_uc_addr_set(struct net_device *dev,
+static void mv643xx_eth_port_mac_addr_get(struct net_device *dev, unsigned char *p_addr);
+static void mv643xx_eth_port_mac_addr_set(struct net_device *dev,
 				 unsigned char *p_addr);
 
 /* PHY and MIB routines */
-static void ethernet_phy_reset(struct net_device *dev);
+static void mv643xx_eth_phy_reset(struct net_device *dev);
 
-static void eth_port_write_smi_reg(struct net_device *dev,
+static void mv643xx_eth_write_smi_reg(struct net_device *dev,
 				   unsigned int phy_reg, unsigned int value);
 
-static void eth_port_read_smi_reg(struct net_device *dev,
+static void mv643xx_eth_read_smi_reg(struct net_device *dev,
 				  unsigned int phy_reg, unsigned int *value);
 
-static void eth_clear_mib_counters(struct net_device *dev);
+static void mv643xx_eth_clear_mib_counters(struct net_device *dev);
 
 /* Port data flow control routines */
-static int eth_port_send(struct net_device *dev,
+static int mv643xx_eth_tx_packet(struct net_device *dev,
 			 struct pkt_info *p_pkt_info);
-static int eth_tx_return_desc(struct net_device *dev,
+static int mv643xx_eth_tx_return_desc(struct net_device *dev,
 			      struct pkt_info *p_pkt_info);
-static int eth_port_receive(struct net_device *dev,
+static int mv643xx_eth_rx_packet(struct net_device *dev,
 			    struct pkt_info *p_pkt_info);
-static void eth_rx_return_buff(struct net_device *dev,
+static void mv643xx_eth_rx_return_buff(struct net_device *dev,
 			       struct pkt_info *p_pkt_info);
 
 static char mv643xx_driver_name[] = "mv643xx_eth";

@@ -135,7 +134,7 @@
 /* used to protect MV643XX_ETH_SMI_REG, which is shared across ports */
 static spinlock_t mv643xx_eth_phy_lock = SPIN_LOCK_UNLOCKED;
 
-static inline u32 mv_read(int offset)
+static inline u32 mv643xx_eth_read(int offset)
 {
 	void *__iomem reg_base;
 

@@ -144,7 +143,7 @@
 	return readl(reg_base + offset);
 }
 
-static inline void mv_write(int offset, u32 data)
+static inline void mv643xx_eth_write(int offset, u32 data)
 {
 	void * __iomem reg_base;
 

@@ -221,7 +220,7 @@
 		pkt_info.buf_ptr = dma_map_single(NULL, skb->data, RX_SKB_SIZE,
 							DMA_FROM_DEVICE);
 		pkt_info.return_info = skb;
-		eth_rx_return_buff(dev, &pkt_info);
+		mv643xx_eth_rx_return_buff(dev, &pkt_info);
 		skb_reserve(skb, 2);
 	}
 	clear_bit(0, &mp->rx_task_busy);

@@ -240,7 +239,7 @@
 #ifdef MV643XX_RX_QUEUE_FILL_ON_TASK
 	else {
 		/* Return interrupts */
-		mv_write(MV643XX_ETH_INTERRUPT_MASK_REG(mp->port_num),
+		mv643xx_eth_write(MV643XX_ETH_INTERRUPT_MASK_REG(mp->port_num),
 							INT_CAUSE_UNMASK_ALL);
 	}
 #endif

@@ -277,9 +276,9 @@
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 
-	eth_port_init_mac_tables(dev);
+	mv643xx_eth_port_init_mac_tables(dev);
 	memcpy(mp->port_mac_addr, dev->dev_addr, 6);
-	eth_port_uc_addr_set(dev, mp->port_mac_addr);
+	mv643xx_eth_port_mac_addr_set(dev, mp->port_mac_addr);
 }
 
 /*

@@ -294,12 +293,12 @@
 {
 	u32 config_reg;
 
-	config_reg = ethernet_get_config_reg(dev);
+	config_reg = mv643xx_eth_get_config_reg(dev);
 	if (dev->flags & IFF_PROMISC)
 		config_reg |= (u32) MV643XX_ETH_UNICAST_PROMISCUOUS_MODE;
 	else
 		config_reg &= ~(u32) MV643XX_ETH_UNICAST_PROMISCUOUS_MODE;
-	ethernet_set_config_reg(dev, config_reg);
+	mv643xx_eth_set_config_reg(dev, config_reg);
 }
 
 /*

@@ -351,8 +350,8 @@
 static void mv643xx_eth_tx_timeout_task(struct net_device *dev)
 {
 	netif_device_detach(dev);
-	eth_port_reset(dev);
-	eth_port_start(dev);
+	mv643xx_eth_port_reset(dev);
+	mv643xx_eth_port_start(dev);
 	netif_device_attach(dev);
 }
 

@@ -377,7 +376,7 @@
 	spin_lock(&mp->lock);
 
 	/* Check only queue 0 */
-	while (eth_tx_return_desc(dev, &pkt_info) == 0) {
+	while (mv643xx_eth_tx_return_desc(dev, &pkt_info) == 0) {
 		if (pkt_info.cmd_sts & BIT0) {
 			if (netif_msg_tx_err(mp))
 				printk(KERN_WARNING "%s: Error in TX: cmd_sts=%08x\n",

@@ -446,9 +445,9 @@
 	struct pkt_info pkt_info;
 
 #ifdef MV643XX_NAPI
-	while (eth_port_receive(dev, &pkt_info) == 0 && budget > 0) {
+	while (mv643xx_eth_rx_packet(dev, &pkt_info) == 0 && budget > 0) {
 #else
-	while (eth_port_receive(dev, &pkt_info) == 0) {
+	while (mv643xx_eth_rx_packet(dev, &pkt_info) == 0) {
 #endif
 		mp->rx_ring_skbs--;
 		received_packets++;

@@ -525,11 +524,11 @@
 	unsigned int port_num = mp->port_num;
 
 	/* Read interrupt cause registers */
-	eth_int_cause = mv_read(MV643XX_ETH_INTERRUPT_CAUSE_REG(port_num)) &
+	eth_int_cause = mv643xx_eth_read(MV643XX_ETH_INTERRUPT_CAUSE_REG(port_num)) &
 						INT_CAUSE_UNMASK_ALL;
 
 	if (eth_int_cause & BIT1)
-		eth_int_cause_ext = mv_read(
+		eth_int_cause_ext = mv643xx_eth_read(
 			MV643XX_ETH_INTERRUPT_CAUSE_EXTEND_REG(port_num)) &
 						INT_CAUSE_UNMASK_ALL_EXT;
 

@@ -541,10 +540,10 @@
 		 * Clear specific ethernet port intrerrupt registers by
 		 * acknowleding relevant bits.
 		 */
-		mv_write(MV643XX_ETH_INTERRUPT_CAUSE_REG(port_num),
+		mv643xx_eth_write(MV643XX_ETH_INTERRUPT_CAUSE_REG(port_num),
 							~eth_int_cause);
 		if (eth_int_cause_ext != 0x0)
-			mv_write(MV643XX_ETH_INTERRUPT_CAUSE_EXTEND_REG
+			mv643xx_eth_write(MV643XX_ETH_INTERRUPT_CAUSE_EXTEND_REG
 					(port_num), ~eth_int_cause_ext);
 
 		/* UDP change : We may need this */

@@ -556,8 +555,8 @@
 	} else {
 		if (netif_rx_schedule_prep(dev)) {
 			/* Mask all the interrupts */
-			mv_write(MV643XX_ETH_INTERRUPT_MASK_REG(port_num), 0);
-			mv_write(MV643XX_ETH_INTERRUPT_EXTEND_MASK_REG
+			mv643xx_eth_write(MV643XX_ETH_INTERRUPT_MASK_REG(port_num), 0);
+			mv643xx_eth_write(MV643XX_ETH_INTERRUPT_EXTEND_MASK_REG
 								(port_num), 0);
 			__netif_rx_schedule(dev);
 		}

@@ -573,7 +572,7 @@
 		 */
 #ifdef MV643XX_RX_QUEUE_FILL_ON_TASK
 		/* Unmask all interrupts on ethernet port */
-		mv_write(MV643XX_ETH_INTERRUPT_MASK_REG(port_num),
+		mv643xx_eth_write(MV643XX_ETH_INTERRUPT_MASK_REG(port_num),
 							INT_CAUSE_MASK_ALL);
 		queue_task(&mp->rx_task, &tq_immediate);
 		mark_bh(IMMEDIATE_BH);

@@ -606,7 +605,7 @@
 
 			netif_wake_queue(dev);
 			/* Start TX queue */
-			mv_write(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(port_num), 1);
+			mv643xx_eth_write(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(port_num), 1);
 
 		} else if(!mii_link_ok(&mp->mii) && netif_carrier_ok(dev)) {
 			netif_stop_queue(dev);

@@ -652,15 +651,15 @@
  *	The interrupt coalescing value set in the gigE port.
  *
  */
-static unsigned int eth_port_set_rx_coal(unsigned int eth_port_num,
+static unsigned int mv643xx_eth_port_set_rx_coal(unsigned int eth_port_num,
 					unsigned int t_clk, unsigned int delay)
 {
 	unsigned int coal = ((t_clk / 1000000) * delay) / 64;
 
 	/* Set RX Coalescing mechanism */
-	mv_write(MV643XX_ETH_SDMA_CONFIG_REG(eth_port_num),
+	mv643xx_eth_write(MV643XX_ETH_SDMA_CONFIG_REG(eth_port_num),
 		((coal & 0x3fff) << 8) |
-		(mv_read(MV643XX_ETH_SDMA_CONFIG_REG(eth_port_num))
+		(mv643xx_eth_read(MV643XX_ETH_SDMA_CONFIG_REG(eth_port_num))
 			& 0xffc000ff));
 
 	return coal;

@@ -690,13 +689,13 @@
  *	The interrupt coalescing value set in the gigE port.
  *
  */
-static unsigned int eth_port_set_tx_coal(unsigned int eth_port_num,
+static unsigned int mv643xx_eth_port_set_tx_coal(unsigned int eth_port_num,
 					unsigned int t_clk, unsigned int delay)
 {
 	unsigned int coal;
 	coal = ((t_clk / 1000000) * delay) / 64;
 	/* Set TX Coalescing mechanism */
-	mv_write(MV643XX_ETH_TX_FIFO_URGENT_THRESHOLD_REG(eth_port_num),
+	mv643xx_eth_write(MV643XX_ETH_TX_FIFO_URGENT_THRESHOLD_REG(eth_port_num),
 								coal << 4);
 	return coal;
 }

@@ -727,7 +726,7 @@
 		mp->port_serial_control |= BIT23;
 }
 
-static int mv643xx_set_settings(struct net_device *dev,
+static int mv643xx_eth_set_settings(struct net_device *dev,
 				    struct ethtool_cmd *cmd)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);

@@ -849,7 +848,7 @@
 	spin_unlock_irq(&mp->lock);
 	
 	if (mp->ethtool_cmd.autoneg || mp->ethtool_cmd.speed)
-		mv643xx_set_settings(dev, &mp->ethtool_cmd);
+		mv643xx_eth_set_settings(dev, &mp->ethtool_cmd);
 
 	return 0;
 

@@ -884,7 +883,7 @@
  * RETURN:
  *	None.
  */
-static void ether_init_rx_desc_ring(struct net_device *dev)
+static void mv643xx_eth_init_rx_desc_ring(struct net_device *dev)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 	volatile struct eth_rx_desc *p_rx_desc;

@@ -930,7 +929,7 @@
  * RETURN:
  *	None.
  */
-static void ether_init_tx_desc_ring(struct net_device *dev)
+static void mv643xx_eth_init_tx_desc_ring(struct net_device *dev)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 	int tx_desc_num = mp->tx_ring_size;

@@ -964,24 +963,24 @@
 	unsigned int size;
 
 	/* Stop RX Queues */
-	mv_write(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(port_num), 0x0000ff00);
+	mv643xx_eth_write(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(port_num), 0x0000ff00);
 
 	/* Clear the ethernet port interrupts */
-	mv_write(MV643XX_ETH_INTERRUPT_CAUSE_REG(port_num), 0);
-	mv_write(MV643XX_ETH_INTERRUPT_CAUSE_EXTEND_REG(port_num), 0);
+	mv643xx_eth_write(MV643XX_ETH_INTERRUPT_CAUSE_REG(port_num), 0);
+	mv643xx_eth_write(MV643XX_ETH_INTERRUPT_CAUSE_EXTEND_REG(port_num), 0);
 
 	/* Unmask RX buffer and TX end interrupt */
-	mv_write(MV643XX_ETH_INTERRUPT_MASK_REG(port_num),
+	mv643xx_eth_write(MV643XX_ETH_INTERRUPT_MASK_REG(port_num),
 						INT_CAUSE_UNMASK_ALL);
 
 	/* Unmask phy and link status changes interrupts */
-	mv_write(MV643XX_ETH_INTERRUPT_EXTEND_MASK_REG(port_num),
+	mv643xx_eth_write(MV643XX_ETH_INTERRUPT_EXTEND_MASK_REG(port_num),
 						INT_CAUSE_UNMASK_ALL_EXT);
 
 	/* Set the MAC Address */
 	memcpy(mp->port_mac_addr, dev->dev_addr, 6);
 
-	eth_port_init(dev);
+	mv643xx_eth_port_init(dev);
 
 	INIT_WORK(&mp->rx_task, (void (*)(void *))mv643xx_eth_rx_task, dev);
 

@@ -1031,7 +1030,7 @@
 	BUG_ON((u32) mp->p_tx_desc_area & 0xf);	/* check 16-byte alignment */
 	memset((void *)mp->p_tx_desc_area, 0, mp->tx_desc_area_size);
 
-	ether_init_tx_desc_ring(dev);
+	mv643xx_eth_init_tx_desc_ring(dev);
 
 	/* Allocate RX ring */
 	mp->rx_ring_skbs = 0;

@@ -1061,21 +1060,21 @@
 	}
 	memset((void *)mp->p_rx_desc_area, 0, size);
 
-	ether_init_rx_desc_ring(dev);
+	mv643xx_eth_init_rx_desc_ring(dev);
 
 	mv643xx_eth_rx_task(dev);	/* Fill RX ring with skb's */
 
-	eth_port_start(dev);
+	mv643xx_eth_port_start(dev);
 
 	/* Interrupt Coalescing */
 
 #ifdef MV643XX_COAL
 	mp->rx_int_coal =
-		eth_port_set_rx_coal(port_num, 133000000, MV643XX_RX_COAL);
+		mv643xx_eth_port_set_rx_coal(port_num, 133000000, MV643XX_RX_COAL);
 #endif
 
 	mp->tx_int_coal =
-		eth_port_set_tx_coal(port_num, 133000000, MV643XX_TX_COAL);
+		mv643xx_eth_port_set_tx_coal(port_num, 133000000, MV643XX_TX_COAL);
 
 	netif_start_queue(dev);
 

@@ -1088,7 +1087,7 @@
 	unsigned int curr;
 
 	/* Stop Tx Queues */
-	mv_write(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(mp->port_num), 0x0000ff00);
+	mv643xx_eth_write(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(mp->port_num), 0x0000ff00);
 
 	/* Free outstanding skb's on TX rings */
 	for (curr = 0; mp->tx_ring_skbs && curr < mp->tx_ring_size; curr++) {

@@ -1115,7 +1114,7 @@
 	int curr;
 
 	/* Stop RX Queues */
-	mv_write(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(mp->port_num), 0x0000ff00);
+	mv643xx_eth_write(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(mp->port_num), 0x0000ff00);
 
 	/* Free preallocated skb's on RX rings */
 	for (curr = 0; mp->rx_ring_skbs && curr < mp->rx_ring_size; curr++) {

@@ -1161,17 +1160,17 @@
 	mv643xx_eth_free_tx_rings(dev);
 	mv643xx_eth_free_rx_rings(dev);
 
-	eth_port_reset(dev);
+	mv643xx_eth_port_reset(dev);
 
 	/* Disable ethernet port interrupts */
-	mv_write(MV643XX_ETH_INTERRUPT_CAUSE_REG(port_num), 0);
-	mv_write(MV643XX_ETH_INTERRUPT_CAUSE_EXTEND_REG(port_num), 0);
+	mv643xx_eth_write(MV643XX_ETH_INTERRUPT_CAUSE_REG(port_num), 0);
+	mv643xx_eth_write(MV643XX_ETH_INTERRUPT_CAUSE_EXTEND_REG(port_num), 0);
 
 	/* Mask RX buffer and TX end interrupt */
-	mv_write(MV643XX_ETH_INTERRUPT_MASK_REG(port_num), 0);
+	mv643xx_eth_write(MV643XX_ETH_INTERRUPT_MASK_REG(port_num), 0);
 
 	/* Mask phy and link status changes interrupts */
-	mv_write(MV643XX_ETH_INTERRUPT_EXTEND_MASK_REG(port_num), 0);
+	mv643xx_eth_write(MV643XX_ETH_INTERRUPT_EXTEND_MASK_REG(port_num), 0);
 
 	return 0;
 }

@@ -1191,12 +1190,12 @@
 }
 
 #ifdef MV643XX_NAPI
-static void mv643xx_tx(struct net_device *dev)
+static void mv643xx_eth_tx(struct net_device *dev)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 	struct pkt_info pkt_info;
 
-	while (eth_tx_return_desc(dev, &pkt_info) == 0) {
+	while (mv643xx_eth_tx_return_desc(dev, &pkt_info) == 0) {
 		if (pkt_info.return_info) {
 			if (skb_shinfo(pkt_info.return_info)->nr_frags)
 				dma_unmap_page(NULL, pkt_info.buf_ptr,

@@ -1226,7 +1225,7 @@
  *
  * This function is used in case of NAPI
  */
-static int mv643xx_poll(struct net_device *dev, int *budget)
+static int mv643xx_eth_poll(struct net_device *dev, int *budget)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 	int done = 1, orig_budget, work_done;

@@ -1236,13 +1235,13 @@
 #ifdef MV643XX_TX_FAST_REFILL
 	if (++mp->tx_clean_threshold > 5) {
 		spin_lock_irqsave(&mp->lock, flags);
-		mv643xx_tx(dev);
+		mv643xx_eth_tx(dev);
 		mp->tx_clean_threshold = 0;
 		spin_unlock_irqrestore(&mp->lock, flags);
 	}
 #endif
 
-	if ((mv_read(MV643XX_ETH_RX_CURRENT_QUEUE_DESC_PTR_0(port_num)))
+	if ((mv643xx_eth_read(MV643XX_ETH_RX_CURRENT_QUEUE_DESC_PTR_0(port_num)))
 						!= (u32) mp->rx_used_desc_q) {
 		orig_budget = *budget;
 		if (orig_budget > dev->quota)

@@ -1258,11 +1257,11 @@
 	if (done) {
 		spin_lock_irqsave(&mp->lock, flags);
 		__netif_rx_complete(dev);
-		mv_write(MV643XX_ETH_INTERRUPT_CAUSE_REG(port_num), 0);
-		mv_write(MV643XX_ETH_INTERRUPT_CAUSE_EXTEND_REG(port_num), 0);
-		mv_write(MV643XX_ETH_INTERRUPT_MASK_REG(port_num),
+		mv643xx_eth_write(MV643XX_ETH_INTERRUPT_CAUSE_REG(port_num), 0);
+		mv643xx_eth_write(MV643XX_ETH_INTERRUPT_CAUSE_EXTEND_REG(port_num), 0);
+		mv643xx_eth_write(MV643XX_ETH_INTERRUPT_MASK_REG(port_num),
 						INT_CAUSE_UNMASK_ALL);
-		mv_write(MV643XX_ETH_INTERRUPT_EXTEND_MASK_REG(port_num),
+		mv643xx_eth_write(MV643XX_ETH_INTERRUPT_EXTEND_MASK_REG(port_num),
 						INT_CAUSE_UNMASK_ALL_EXT);
 		spin_unlock_irqrestore(&mp->lock, flags);
 	}

@@ -1347,7 +1346,7 @@
 							DMA_TO_DEVICE);
 		pkt_info.return_info = skb;
 		mp->tx_ring_skbs++;
-		status = eth_port_send(dev, &pkt_info);
+		status = mv643xx_eth_tx_packet(dev, &pkt_info);
 		if (status < 0)
 			goto out;
 

@@ -1405,7 +1404,7 @@
 			}
 		}
 
-		status = eth_port_send(dev, &pkt_info);
+		status = mv643xx_eth_tx_packet(dev, &pkt_info);
 		if (status < 0)
 			goto out;
 

@@ -1434,7 +1433,7 @@
 							this_frag->size,
 							DMA_TO_DEVICE);
 
-			status = eth_port_send(dev, &pkt_info);
+			status = mv643xx_eth_tx_packet(dev, &pkt_info);
 			if (status < 0)
 				goto out;
 

@@ -1450,7 +1449,7 @@
 								DMA_TO_DEVICE);
 	pkt_info.return_info = skb;
 	mp->tx_ring_skbs++;
-	status = eth_port_send(dev, &pkt_info);
+	status = mv643xx_eth_tx_packet(dev, &pkt_info);
 	if (status < 0)
 		goto out;
 

@@ -1495,7 +1494,7 @@
 	return &mp->stats;
 }
 
-/*/
+/*
  * mv643xx_eth_probe
  *
  * First function called after registering the network device.

@@ -1549,7 +1548,7 @@
 	/* No need to Tx Timeout */
 	dev->tx_timeout = mv643xx_eth_tx_timeout;
 #ifdef MV643XX_NAPI
-	dev->poll = mv643xx_poll;
+	dev->poll = mv643xx_eth_poll;
 	dev->weight = 64;
 #endif
 

@@ -1577,9 +1576,9 @@
 	spin_lock_init(&mp->lock);
 
 	/* set default config values */
-	eth_port_uc_addr_get(dev, dev->dev_addr);
+	mv643xx_eth_port_mac_addr_get(dev, dev->dev_addr);
 	mp->port_serial_control =
-		mv_read(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num));
+		mv643xx_eth_read(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num));
 	mp->port_serial_control &= ~MV643XX_ETH_SERIAL_PORT_ENABLE;
 	mp->port_serial_control |= MV643XX_ETH_DISABLE_AUTO_NEG_FOR_FLOW_CTRL |
 				   MV643XX_ETH_SERIAL_PORT_CONTROL_RESERVED   |

@@ -1619,25 +1618,25 @@
 						    ADVERTISED_Autoneg	      |
 						    ADVERTISED_MII;
 
-			ethernet_phy_set(dev, ecmd->phy_address);
+			mv643xx_eth_phy_set(dev, ecmd->phy_address);
 			memcpy(&mp->ethtool_cmd, ecmd, sizeof *ecmd);
 			mv643xx_eth_update_pscr(dev, ecmd);
 		}
 	}
-
 	/* Hook up MII support for ethtool */
 	mp->mii.dev = dev;
-	mp->mii.mdio_read = mv643xx_mdio_read;
-	mp->mii.mdio_write = mv643xx_mdio_write;
-	mp->mii.phy_id = ethernet_phy_get(dev);
+	mp->mii.mdio_read = mv643xx_eth_mdio_read;
+	mp->mii.mdio_write = mv643xx_eth_mdio_write;
+	mp->mii.phy_id = mv643xx_eth_phy_get(dev);
 	mp->mii.phy_id_mask = 0x3f;
 	mp->mii.reg_num_mask = 0x1f;
 
-	err = ethernet_phy_detect(dev);
+	err = mv643xx_eth_phy_detect(dev);
+
 	if (err) {
 		printk(KERN_ERR "MV643xx ethernet port %d: "
 		       "No PHY detected at addr %d\n",
-		       port_num, ethernet_phy_get(dev));
+		       port_num, mv643xx_eth_phy_get(dev));
 		return err;
 	}
 

@@ -1751,7 +1750,7 @@
  *
  * Output :	N/A
  */
-static int __init mv643xx_init_module(void)
+static int __init mv643xx_eth_init_module(void)
 {
 	int rc;
 

@@ -1773,14 +1772,14 @@
  *
  * Output :	N/A
  */
-static void __exit mv643xx_cleanup_module(void)
+static void __exit mv643xx_eth_cleanup_module(void)
 {
 	driver_unregister(&mv643xx_eth_driver);
 	driver_unregister(&mv643xx_eth_shared_driver);
 }
 
-module_init(mv643xx_init_module);
-module_exit(mv643xx_cleanup_module);
+module_init(mv643xx_eth_init_module);
+module_exit(mv643xx_eth_cleanup_module);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR(	"Rabeeh Khoury, Assaf Hoffman, Matthew Dharm, Manish Lachwani"

@@ -1930,12 +1929,10 @@
 /* defines */
 /* SDMA command macros */
 #define ETH_ENABLE_TX_QUEUE(eth_port) \
-	mv_write(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(eth_port), 1)
-
-/* locals */
+	mv643xx_eth_write(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(eth_port), 1)
 
 /* Ethernet Port routines */
-static int eth_port_uc_addr(unsigned int eth_port_num, unsigned char uc_nibble,
+static int mv643xx_eth_port_mac_addr(unsigned int eth_port_num, unsigned char uc_nibble,
 								int option);
 
 /*

@@ -1962,7 +1959,7 @@
  * RETURN:
  *	None.
  */
-static void eth_port_init(struct net_device *dev)
+static void mv643xx_eth_port_init(struct net_device *dev)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 

@@ -1972,11 +1969,11 @@
 	mp->rx_resource_err = 0;
 	mp->tx_resource_err = 0;
 
-	eth_port_reset(dev);
+	mv643xx_eth_port_reset(dev);
 
-	eth_port_init_mac_tables(dev);
+	mv643xx_eth_port_init_mac_tables(dev);
 
-	ethernet_phy_reset(dev);
+	mv643xx_eth_phy_reset(dev);
 }
 
 /*

@@ -2006,7 +2003,7 @@
  * RETURN:
  *	None.
  */
-static void eth_port_start(struct net_device *dev)
+static void mv643xx_eth_port_start(struct net_device *dev)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 	unsigned int port_num = mp->port_num;

@@ -2014,47 +2011,46 @@
 
 	/* Assignment of Tx CTRP of given queue */
 	tx_curr_desc = mp->tx_curr_desc_q;
-	mv_write(MV643XX_ETH_TX_CURRENT_QUEUE_DESC_PTR_0(port_num),
+	mv643xx_eth_write(MV643XX_ETH_TX_CURRENT_QUEUE_DESC_PTR_0(port_num),
 		(u32)((struct eth_tx_desc *)mp->tx_desc_dma + tx_curr_desc));
 
 	/* Assignment of Rx CRDP of given queue */
 	rx_curr_desc = mp->rx_curr_desc_q;
-	mv_write(MV643XX_ETH_RX_CURRENT_QUEUE_DESC_PTR_0(port_num),
+	mv643xx_eth_write(MV643XX_ETH_RX_CURRENT_QUEUE_DESC_PTR_0(port_num),
 		(u32)((struct eth_rx_desc *)mp->rx_desc_dma + rx_curr_desc));
 
 	/* Add the assigned Ethernet address to the port's address table */
-	eth_port_uc_addr_set(dev, mp->port_mac_addr);
+	mv643xx_eth_port_mac_addr_set(dev, mp->port_mac_addr);
 
 	/* Assign port configuration and command. */
-	mv_write(MV643XX_ETH_PORT_CONFIG_REG(port_num),
+	mv643xx_eth_write(MV643XX_ETH_PORT_CONFIG_REG(port_num),
 			  MV643XX_ETH_PORT_CONFIG_DEFAULT_VALUE);
 
-	mv_write(MV643XX_ETH_PORT_CONFIG_EXTEND_REG(port_num),
+	mv643xx_eth_write(MV643XX_ETH_PORT_CONFIG_EXTEND_REG(port_num),
 			  MV643XX_ETH_PORT_CONFIG_EXTEND_DEFAULT_VALUE);
 
 	/* the mv643xx users manual says the following read/write are needed */
-	mv_read(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num));
-	mv_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num), 0);
-
+	mv643xx_eth_read(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num));
+	mv643xx_eth_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num), 0);
 
 	/* Increase the Rx side buffer size if supporting GigE */
 	if (mp->port_serial_control & MV643XX_ETH_SET_GMII_SPEED_TO_1000)
-		mv_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num),
+		mv643xx_eth_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num),
 			(mp->port_serial_control & 0xfff1ffff) | (0x5 << 17));
 	else
-		mv_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num),
+		mv643xx_eth_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num),
 						mp->port_serial_control);
 
-	mv_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num),
-			mp->port_serial_control |
-			MV643XX_ETH_SERIAL_PORT_ENABLE);
+	mv643xx_eth_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num),
+			  mp->port_serial_control |
+			  MV643XX_ETH_SERIAL_PORT_ENABLE);
 
 	/* Assign port SDMA configuration */
-	mv_write(MV643XX_ETH_SDMA_CONFIG_REG(port_num),
+	mv643xx_eth_write(MV643XX_ETH_SDMA_CONFIG_REG(port_num),
 			  MV643XX_ETH_PORT_SDMA_CONFIG_DEFAULT_VALUE);
 
 	/* Enable port Rx. */
-	mv_write(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(port_num),
+	mv643xx_eth_write(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(port_num),
 						mp->port_rx_queue_command);
 }
 

@@ -2076,8 +2072,8 @@
  *	N/A.
  *
  */
-static void eth_port_uc_addr_set(struct net_device *dev,
-				 unsigned char *p_addr)
+static void mv643xx_eth_port_mac_addr_set(struct net_device *dev,
+					  unsigned char *p_addr)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 	unsigned int eth_port_num = mp->port_num;

@@ -2088,11 +2084,11 @@
 	mac_h = (p_addr[0] << 24) | (p_addr[1] << 16) | (p_addr[2] << 8) |
 							(p_addr[3] << 0);
 
-	mv_write(MV643XX_ETH_MAC_ADDR_LOW(eth_port_num), mac_l);
-	mv_write(MV643XX_ETH_MAC_ADDR_HIGH(eth_port_num), mac_h);
+	mv643xx_eth_write(MV643XX_ETH_MAC_ADDR_LOW(eth_port_num), mac_l);
+	mv643xx_eth_write(MV643XX_ETH_MAC_ADDR_HIGH(eth_port_num), mac_h);
 
 	/* Accept frames of this address */
-	eth_port_uc_addr(eth_port_num, p_addr[5], ACCEPT_MAC_ADDR);
+	mv643xx_eth_port_mac_addr(eth_port_num, p_addr[5], ACCEPT_MAC_ADDR);
 
 	return;
 }

@@ -2115,14 +2111,14 @@
  *	N/A.
  *
  */
-static void eth_port_uc_addr_get(struct net_device *dev, unsigned char *p_addr)
+static void mv643xx_eth_port_mac_addr_get(struct net_device *dev, unsigned char *p_addr)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 	unsigned int mac_h;
 	unsigned int mac_l;
 
-	mac_h = mv_read(MV643XX_ETH_MAC_ADDR_HIGH(mp->port_num));
-	mac_l = mv_read(MV643XX_ETH_MAC_ADDR_LOW(mp->port_num));
+	mac_h = mv643xx_eth_read(MV643XX_ETH_MAC_ADDR_HIGH(mp->port_num));
+	mac_l = mv643xx_eth_read(MV643XX_ETH_MAC_ADDR_LOW(mp->port_num));
 
 	p_addr[0] = (mac_h >> 24) & 0xff;
 	p_addr[1] = (mac_h >> 16) & 0xff;

@@ -2154,7 +2150,7 @@
  *	false if option parameter is invalid.
  *
  */
-static int eth_port_uc_addr(unsigned int eth_port_num, unsigned char uc_nibble,
+static int mv643xx_eth_port_mac_addr(unsigned int eth_port_num, unsigned char uc_nibble,
 								int option)
 {
 	unsigned int unicast_reg;

@@ -2169,24 +2165,24 @@
 	switch (option) {
 	case REJECT_MAC_ADDR:
 		/* Clear accepts frame bit at given unicast DA table entry */
-		unicast_reg = mv_read((MV643XX_ETH_DA_FILTER_UNICAST_TABLE_BASE
+		unicast_reg = mv643xx_eth_read((MV643XX_ETH_DA_FILTER_UNICAST_TABLE_BASE
 						(eth_port_num) + tbl_offset));
 
 		unicast_reg &= (0x0E << (8 * reg_offset));
 
-		mv_write((MV643XX_ETH_DA_FILTER_UNICAST_TABLE_BASE
+		mv643xx_eth_write((MV643XX_ETH_DA_FILTER_UNICAST_TABLE_BASE
 				(eth_port_num) + tbl_offset), unicast_reg);
 		break;
 
 	case ACCEPT_MAC_ADDR:
 		/* Set accepts frame bit at unicast DA filter table entry */
 		unicast_reg =
-			mv_read((MV643XX_ETH_DA_FILTER_UNICAST_TABLE_BASE
+			mv643xx_eth_read((MV643XX_ETH_DA_FILTER_UNICAST_TABLE_BASE
 						(eth_port_num) + tbl_offset));
 
 		unicast_reg |= (0x01 << (8 * reg_offset));
 
-		mv_write((MV643XX_ETH_DA_FILTER_UNICAST_TABLE_BASE
+		mv643xx_eth_write((MV643XX_ETH_DA_FILTER_UNICAST_TABLE_BASE
 				(eth_port_num) + tbl_offset), unicast_reg);
 
 		break;

@@ -2214,7 +2210,7 @@
  * RETURN:
  *	None.
  */
-static void eth_port_init_mac_tables(struct net_device *dev)
+static void mv643xx_eth_port_init_mac_tables(struct net_device *dev)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 	int table_index;

@@ -2222,15 +2218,15 @@
 
 	/* Clear DA filter unicast table (Ex_dFUT) */
 	for (table_index = 0; table_index <= 0xC; table_index += 4)
-		mv_write((MV643XX_ETH_DA_FILTER_UNICAST_TABLE_BASE
+		mv643xx_eth_write((MV643XX_ETH_DA_FILTER_UNICAST_TABLE_BASE
 					(eth_port_num) + table_index), 0);
 
 	for (table_index = 0; table_index <= 0xFC; table_index += 4) {
 		/* Clear DA filter special multicast table (Ex_dFSMT) */
-		mv_write((MV643XX_ETH_DA_FILTER_SPECIAL_MULTICAST_TABLE_BASE
+		mv643xx_eth_write((MV643XX_ETH_DA_FILTER_SPECIAL_MULTICAST_TABLE_BASE
 					(eth_port_num) + table_index), 0);
 		/* Clear DA filter other multicast table (Ex_dFOMT) */
-		mv_write((MV643XX_ETH_DA_FILTER_OTHER_MULTICAST_TABLE_BASE
+		mv643xx_eth_write((MV643XX_ETH_DA_FILTER_OTHER_MULTICAST_TABLE_BASE
 					(eth_port_num) + table_index), 0);
 	}
 }

@@ -2252,7 +2248,7 @@
  *	MIB counter value.
  *
  */
-static void eth_clear_mib_counters(struct net_device *dev)
+static void mv643xx_eth_clear_mib_counters(struct net_device *dev)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 	unsigned int eth_port_num = mp->port_num;

@@ -2261,40 +2257,45 @@
 	/* Perform dummy reads from MIB counters */
 	for (i = ETH_MIB_GOOD_OCTETS_RECEIVED_LOW; i < ETH_MIB_LATE_COLLISION;
 									i += 4)
-		mv_read(MV643XX_ETH_MIB_COUNTERS_BASE(eth_port_num) + i);
+		mv643xx_eth_read(MV643XX_ETH_MIB_COUNTERS_BASE(eth_port_num) + i);
 }
 
-static inline u32 read_mib(struct net_device *dev, int offset)
+static inline u32 mv643xx_eth_read_mib_counter(struct net_device *dev,
+					       int offset)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 
-	return mv_read(MV643XX_ETH_MIB_COUNTERS_BASE(mp->port_num) + offset);
+	return mv643xx_eth_read(MV643XX_ETH_MIB_COUNTERS_BASE(mp->port_num) + offset);
 }
 
-static void eth_update_mib_counters(struct net_device *dev)
+static void mv643xx_eth_update_mib_counters(struct net_device *dev)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 	struct mv643xx_mib_counters *p = &mp->mib_counters;
 	int offset;
 
 	p->good_octets_received +=
-		read_mib(dev, ETH_MIB_GOOD_OCTETS_RECEIVED_LOW);
+	    mv643xx_eth_read_mib_counter(dev, ETH_MIB_GOOD_OCTETS_RECEIVED_LOW);
 	p->good_octets_received +=
-		(u64)read_mib(dev, ETH_MIB_GOOD_OCTETS_RECEIVED_HIGH) << 32;
-
+	    (u64) mv643xx_eth_read_mib_counter(dev,
+					       ETH_MIB_GOOD_OCTETS_RECEIVED_HIGH)
+	    << 32;
 	for (offset = ETH_MIB_BAD_OCTETS_RECEIVED;
 			offset <= ETH_MIB_FRAMES_1024_TO_MAX_OCTETS;
 			offset += 4)
-		*(u32 *)((char *)p + offset) = read_mib(dev, offset);
+		*(u32 *)((char *)p + offset) =
+		    mv643xx_eth_read_mib_counter(dev, offset);
 
-	p->good_octets_sent += read_mib(dev, ETH_MIB_GOOD_OCTETS_SENT_LOW);
 	p->good_octets_sent +=
-		(u64)read_mib(dev, ETH_MIB_GOOD_OCTETS_SENT_HIGH) << 32;
+	    mv643xx_eth_read_mib_counter(dev, ETH_MIB_GOOD_OCTETS_SENT_LOW);
+	p->good_octets_sent +=
+	    (u64) mv643xx_eth_read_mib_counter(dev, ETH_MIB_GOOD_OCTETS_SENT_HIGH) << 32;
 
 	for (offset = ETH_MIB_GOOD_FRAMES_SENT;
 			offset <= ETH_MIB_LATE_COLLISION;
 			offset += 4)
-		*(u32 *)((char *)p + offset) = read_mib(dev, offset);
+		*(u32 *)((char *)p + offset) =
+		    mv643xx_eth_read_mib_counter(dev, offset);
 }
 
 /*

@@ -2315,22 +2316,22 @@
  *	-ENODEV on failure
  *
  */
-static int ethernet_phy_detect(struct net_device *dev)
+static int mv643xx_eth_phy_detect(struct net_device *dev)
 {
 	unsigned int phy_reg_data0;
 	int auto_neg;
 
-	eth_port_read_smi_reg(dev, 0, &phy_reg_data0);
+	mv643xx_eth_read_smi_reg(dev, 0, &phy_reg_data0);
 	auto_neg = phy_reg_data0 & 0x1000;
 	phy_reg_data0 ^= 0x1000;	/* invert auto_neg */
-	eth_port_write_smi_reg(dev, 0, phy_reg_data0);
+	mv643xx_eth_write_smi_reg(dev, 0, phy_reg_data0);
 
-	eth_port_read_smi_reg(dev, 0, &phy_reg_data0);
+	mv643xx_eth_read_smi_reg(dev, 0, &phy_reg_data0);
 	if ((phy_reg_data0 & 0x1000) == auto_neg)
 		return -ENODEV;				/* change didn't take */
 
 	phy_reg_data0 ^= 0x1000;
-	eth_port_write_smi_reg(dev, 0, phy_reg_data0);
+	mv643xx_eth_write_smi_reg(dev, 0, phy_reg_data0);
 	return 0;
 }
 

@@ -2350,12 +2351,12 @@
  *	PHY address.
  *
  */
-static int ethernet_phy_get(struct net_device *dev)
+static int mv643xx_eth_phy_get(struct net_device *dev)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 	unsigned int reg_data;
 
-	reg_data = mv_read(MV643XX_ETH_PHY_ADDR_REG);
+	reg_data = mv643xx_eth_read(MV643XX_ETH_PHY_ADDR_REG);
 
 	return ((reg_data >> (5 * mp->port_num)) & 0x1f);
 }

@@ -2377,16 +2378,16 @@
  *	None.
  *
  */
-static void ethernet_phy_set(struct net_device *dev, int phy_addr)
+static void mv643xx_eth_phy_set(struct net_device *dev, int phy_addr)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 	u32 reg_data;
 	int addr_shift = 5 * mp->port_num;
 
-	reg_data = mv_read(MV643XX_ETH_PHY_ADDR_REG);
+	reg_data = mv643xx_eth_read(MV643XX_ETH_PHY_ADDR_REG);
 	reg_data &= ~(0x1f << addr_shift);
 	reg_data |= (phy_addr & 0x1f) << addr_shift;
-	mv_write(MV643XX_ETH_PHY_ADDR_REG, reg_data);
+	mv643xx_eth_write(MV643XX_ETH_PHY_ADDR_REG, reg_data);
 }
 
 /*

@@ -2405,14 +2406,14 @@
  *	None.
  *
  */
-static void ethernet_phy_reset(struct net_device *dev)
+static void mv643xx_eth_phy_reset(struct net_device *dev)
 {
 	unsigned int phy_reg_data;
 
 	/* Reset the PHY */
-	eth_port_read_smi_reg(dev, 0, &phy_reg_data);
+	mv643xx_eth_read_smi_reg(dev, 0, &phy_reg_data);
 	phy_reg_data |= 0x8000;	/* Set bit 15 to reset the PHY */
-	eth_port_write_smi_reg(dev, 0, phy_reg_data);
+	mv643xx_eth_write_smi_reg(dev, 0, phy_reg_data);
 }
 
 /*

@@ -2433,49 +2434,49 @@
  *	None.
  *
  */
-static void eth_port_reset(struct net_device *dev)
+static void mv643xx_eth_port_reset(struct net_device *dev)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 	unsigned int port_num = mp->port_num;
 	unsigned int reg_data;
 
 	/* Stop Tx port activity. Check port Tx activity. */
-	reg_data = mv_read(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(port_num));
+	reg_data = mv643xx_eth_read(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(port_num));
 
 	if (reg_data & 0xFF) {
 		/* Issue stop command for active channels only */
-		mv_write(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(port_num),
+		mv643xx_eth_write(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(port_num),
 							(reg_data << 8));
 
 		/* Wait for all Tx activity to terminate. */
 		/* Check port cause register that all Tx queues are stopped */
-		while (mv_read(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(port_num))
+		while (mv643xx_eth_read(MV643XX_ETH_TRANSMIT_QUEUE_COMMAND_REG(port_num))
 									& 0xFF)
 			udelay(10);
 	}
 
 	/* Stop Rx port activity. Check port Rx activity. */
-	reg_data = mv_read(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(port_num));
+	reg_data = mv643xx_eth_read(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(port_num));
 
 	if (reg_data & 0xFF) {
 		/* Issue stop command for active channels only */
-		mv_write(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(port_num),
+		mv643xx_eth_write(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(port_num),
 							(reg_data << 8));
 
 		/* Wait for all Rx activity to terminate. */
 		/* Check port cause register that all Rx queues are stopped */
-		while (mv_read(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(port_num))
+		while (mv643xx_eth_read(MV643XX_ETH_RECEIVE_QUEUE_COMMAND_REG(port_num))
 									& 0xFF)
 			udelay(10);
 	}
 
 	/* Clear all MIB counters */
-	eth_clear_mib_counters(dev);
+	mv643xx_eth_clear_mib_counters(dev);
 
 	/* Reset the Enable bit in the Configuration Register */
-	reg_data = mv_read(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num));
+	reg_data = mv643xx_eth_read(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num));
 	reg_data &= ~MV643XX_ETH_SERIAL_PORT_ENABLE;
-	mv_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num), reg_data);
+	mv643xx_eth_write(MV643XX_ETH_PORT_SERIAL_CONTROL_REG(port_num), reg_data);
 }
 
 /*

@@ -2497,16 +2498,16 @@
  *	None.
  *
  */
-static void ethernet_set_config_reg(struct net_device *dev,
-				    unsigned int value)
+static void mv643xx_eth_set_config_reg(struct net_device *dev,
+				       unsigned int value)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 	unsigned int eth_port_num = mp->port_num;
 	unsigned int eth_config_reg;
 
-	eth_config_reg = mv_read(MV643XX_ETH_PORT_CONFIG_REG(eth_port_num));
+	eth_config_reg = mv643xx_eth_read(MV643XX_ETH_PORT_CONFIG_REG(eth_port_num));
 	eth_config_reg |= value;
-	mv_write(MV643XX_ETH_PORT_CONFIG_REG(eth_port_num), eth_config_reg);
+	mv643xx_eth_write(MV643XX_ETH_PORT_CONFIG_REG(eth_port_num), eth_config_reg);
 }
 
 /*

@@ -2525,12 +2526,12 @@
  * RETURN:
  *	Port configuration register value.
  */
-static unsigned int ethernet_get_config_reg(struct net_device *dev)
+static unsigned int mv643xx_eth_get_config_reg(struct net_device *dev)
 {
 	struct mv643xx_private *mp = netdev_priv(dev);
 	unsigned int eth_config_reg;
 
-	eth_config_reg = mv_read(MV643XX_ETH_PORT_CONFIG_EXTEND_REG
+	eth_config_reg = mv643xx_eth_read(MV643XX_ETH_PORT_CONFIG_EXTEND_REG
 								(mp->port_num));
 	return eth_config_reg;
 }

@@ -2555,10 +2556,10 @@
  *	true otherwise.
  *
  */
-static void eth_port_read_smi_reg(struct net_device *dev,
+static void mv643xx_eth_read_smi_reg(struct net_device *dev,
 				unsigned int phy_reg, unsigned int *value)
 {
-	int phy_addr = ethernet_phy_get(dev);
+	int phy_addr = mv643xx_eth_phy_get(dev);
 	unsigned long flags;
 	int i;
 

@@ -2566,7 +2567,7 @@
 	spin_lock_irqsave(&mv643xx_eth_phy_lock, flags);
 
 	/* wait for the SMI register to become available */
-	for (i = 0; mv_read(MV643XX_ETH_SMI_REG) & ETH_SMI_BUSY; i++) {
+	for (i = 0; mv643xx_eth_read(MV643XX_ETH_SMI_REG) & ETH_SMI_BUSY; i++) {
 		if (i == PHY_WAIT_ITERATIONS) {
 			printk(KERN_ERR "%s: PHY busy timeout\n", 
 			       dev->name);

@@ -2575,11 +2576,11 @@
 		udelay(PHY_WAIT_MICRO_SECONDS);
 	}
 
-	mv_write(MV643XX_ETH_SMI_REG,
+	mv643xx_eth_write(MV643XX_ETH_SMI_REG,
 		(phy_addr << 16) | (phy_reg << 21) | ETH_SMI_OPCODE_READ);
 
 	/* now wait for the data to be valid */
-	for (i = 0; !(mv_read(MV643XX_ETH_SMI_REG) & ETH_SMI_READ_VALID); i++) {
+	for (i = 0; !(mv643xx_eth_read(MV643XX_ETH_SMI_REG) & ETH_SMI_READ_VALID); i++) {
 		if (i == PHY_WAIT_ITERATIONS) {
 			printk(KERN_ERR "%s: PHY read timeout\n",
 			       dev->name);

@@ -2588,7 +2589,7 @@
 		udelay(PHY_WAIT_MICRO_SECONDS);
 	}
 
-	*value = mv_read(MV643XX_ETH_SMI_REG) & 0xffff;
+	*value = mv643xx_eth_read(MV643XX_ETH_SMI_REG) & 0xffff;
 out:
 	spin_unlock_irqrestore(&mv643xx_eth_phy_lock, flags);
 }

@@ -2613,20 +2614,20 @@
  *	true otherwise.
  *
  */
-static void eth_port_write_smi_reg(struct net_device *dev,
-				   unsigned int phy_reg, unsigned int value)
+static void mv643xx_eth_write_smi_reg(struct net_device *dev,
+				      unsigned int phy_reg, unsigned int value)
 {
 	int phy_addr;
 	int i;
 	unsigned long flags;
 
-	phy_addr = ethernet_phy_get(dev);
+	phy_addr = mv643xx_eth_phy_get(dev);
 
 	/* the SMI register is a shared resource */
 	spin_lock_irqsave(&mv643xx_eth_phy_lock, flags);
 
 	/* wait for the SMI register to become available */
-	for (i = 0; mv_read(MV643XX_ETH_SMI_REG) & ETH_SMI_BUSY; i++) {
+	for (i = 0; mv643xx_eth_read(MV643XX_ETH_SMI_REG) & ETH_SMI_BUSY; i++) {
 		if (i == PHY_WAIT_ITERATIONS) {
 			printk(KERN_ERR "%s: PHY busy timeout\n", 
 			       dev->name);

@@ -2635,7 +2636,7 @@
 		udelay(PHY_WAIT_MICRO_SECONDS);
 	}
 
-	mv_write(MV643XX_ETH_SMI_REG, (phy_addr << 16) | (phy_reg << 21) |
+	mv643xx_eth_write(MV643XX_ETH_SMI_REG, (phy_addr << 16) | (phy_reg << 21) |
 				ETH_SMI_OPCODE_WRITE | (value & 0xffff));
 out:
 	spin_unlock_irqrestore(&mv643xx_eth_phy_lock, flags);

@@ -2644,17 +2645,17 @@
 /*
  * Wrappers for MII support library.
  */
-static int mv643xx_mdio_read(struct net_device *dev, int phy_id, int location)
+static int mv643xx_eth_mdio_read(struct net_device *dev, int phy_id, int location)
 {
 	int val;
 
-	eth_port_read_smi_reg(dev, location, &val);
+	mv643xx_eth_read_smi_reg(dev, location, &val);
 	return val;
 }
 
-static void mv643xx_mdio_write(struct net_device *dev, int phy_id, int location, int val)
+static void mv643xx_eth_mdio_write(struct net_device *dev, int phy_id, int location, int val)
 {
-	eth_port_write_smi_reg(dev, location, val);
+	mv643xx_eth_write_smi_reg(dev, location, val);
 }
 
 /*