u32 late_collision;
 };
 
+struct mv643xx_shared_private {
+       void __iomem *eth_base;
+
+       /* used to protect SMI_REG, which is shared across ports */
+       spinlock_t phy_lock;
+};
+
 struct mv643xx_private {
+       struct mv643xx_shared_private *shared;
        int port_num;                   /* User Ethernet port number    */
 
        u32 rx_sram_addr;               /* Base address of rx sram area */
 static char mv643xx_driver_name[] = "mv643xx_eth";
 static char mv643xx_driver_version[] = "1.0";
 
-static void __iomem *mv643xx_eth_base;
-
-/* used to protect SMI_REG, which is shared across ports */
-static DEFINE_SPINLOCK(mv643xx_eth_phy_lock);
-
 static inline u32 rdl(struct mv643xx_private *mp, int offset)
 {
-       return readl(mv643xx_eth_base + offset);
+       return readl(mp->shared->eth_base + offset);
 }
 
 static inline void wrl(struct mv643xx_private *mp, int offset, u32 data)
 {
-       writel(data, mv643xx_eth_base + offset);
+       writel(data, mp->shared->eth_base + offset);
 }
 
 /*
                return -ENODEV;
        }
 
+       if (pd->shared == NULL) {
+               printk(KERN_ERR "No mv643xx_eth_platform_data->shared\n");
+               return -ENODEV;
+       }
+
        dev = alloc_etherdev(sizeof(struct mv643xx_private));
        if (!dev)
                return -ENOMEM;
 
        spin_lock_init(&mp->lock);
 
+       mp->shared = platform_get_drvdata(pd->shared);
        port_num = mp->port_num = pd->port_number;
 
        /* set default config values */
 static int mv643xx_eth_shared_probe(struct platform_device *pdev)
 {
        static int mv643xx_version_printed = 0;
+       struct mv643xx_shared_private *msp;
        struct resource *res;
+       int ret;
 
        if (!mv643xx_version_printed++)
                printk(KERN_NOTICE "MV-643xx 10/100/1000 Ethernet Driver\n");
 
+       ret = -EINVAL;
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (res == NULL)
-               return -ENODEV;
+               goto out;
 
-       mv643xx_eth_base = ioremap(res->start, res->end - res->start + 1);
-       if (mv643xx_eth_base == NULL)
-               return -ENOMEM;
+       ret = -ENOMEM;
+       msp = kmalloc(sizeof(*msp), GFP_KERNEL);
+       if (msp == NULL)
+               goto out;
+       memset(msp, 0, sizeof(*msp));
+
+       msp->eth_base = ioremap(res->start, res->end - res->start + 1);
+       if (msp->eth_base == NULL)
+               goto out_free;
+
+       spin_lock_init(&msp->phy_lock);
+
+       platform_set_drvdata(pdev, msp);
 
        return 0;
 
+out_free:
+       kfree(msp);
+out:
+       return ret;
 }
 
 static int mv643xx_eth_shared_remove(struct platform_device *pdev)
 {
-       iounmap(mv643xx_eth_base);
-       mv643xx_eth_base = NULL;
+       struct mv643xx_shared_private *msp = platform_get_drvdata(pdev);
+
+       iounmap(msp->eth_base);
+       kfree(msp);
 
        return 0;
 }
        int i;
 
        /* the SMI register is a shared resource */
-       spin_lock_irqsave(&mv643xx_eth_phy_lock, flags);
+       spin_lock_irqsave(&mp->shared->phy_lock, flags);
 
        /* wait for the SMI register to become available */
        for (i = 0; rdl(mp, SMI_REG) & ETH_SMI_BUSY; i++) {
 
        *value = rdl(mp, SMI_REG) & 0xffff;
 out:
-       spin_unlock_irqrestore(&mv643xx_eth_phy_lock, flags);
+       spin_unlock_irqrestore(&mp->shared->phy_lock, flags);
 }
 
 /*
        phy_addr = ethernet_phy_get(mp);
 
        /* the SMI register is a shared resource */
-       spin_lock_irqsave(&mv643xx_eth_phy_lock, flags);
+       spin_lock_irqsave(&mp->shared->phy_lock, flags);
 
        /* wait for the SMI register to become available */
        for (i = 0; rdl(mp, SMI_REG) & ETH_SMI_BUSY; i++) {
        wrl(mp, SMI_REG, (phy_addr << 16) | (phy_reg << 21) |
                                ETH_SMI_OPCODE_WRITE | (value & 0xffff));
 out:
-       spin_unlock_irqrestore(&mv643xx_eth_phy_lock, flags);
+       spin_unlock_irqrestore(&mp->shared->phy_lock, flags);
 }
 
 /*