d->netdev = &orion_ge00.dev;
        for (i = 0; i < d->nr_chips; i++)
-               d->chip[i].mii_bus = &orion_ge00_shared.dev;
+               d->chip[i].host_dev = &orion_ge00_shared.dev;
        orion_switch_device.dev.platform_data = d;
 
        platform_device_register(&orion_switch_device);
 
        return BCM_SF2_STATS_SIZE;
 }
 
-static char *bcm_sf2_sw_probe(struct mii_bus *bus, int sw_addr)
+static char *bcm_sf2_sw_probe(struct device *host_dev, int sw_addr)
 {
        return "Broadcom Starfighter 2";
 }
 
 
 static int reg_read(struct dsa_switch *ds, int addr, int reg)
 {
-       return mdiobus_read(ds->master_mii_bus, ds->pd->sw_addr + addr, reg);
+       return mdiobus_read(to_mii_bus(ds->master_dev),
+                           ds->pd->sw_addr + addr, reg);
 }
 
 #define REG_READ(addr, reg)                                    \
 
 static int reg_write(struct dsa_switch *ds, int addr, int reg, u16 val)
 {
-       return mdiobus_write(ds->master_mii_bus, ds->pd->sw_addr + addr,
-                            reg, val);
+       return mdiobus_write(to_mii_bus(ds->master_dev),
+                            ds->pd->sw_addr + addr, reg, val);
 }
 
 #define REG_WRITE(addr, reg, val)                              \
                        return __ret;                           \
        })
 
-static char *mv88e6060_probe(struct mii_bus *bus, int sw_addr)
+static char *mv88e6060_probe(struct device *host_dev, int sw_addr)
 {
+       struct mii_bus *bus = dsa_host_dev_to_mii_bus(host_dev);
        int ret;
 
+       if (bus == NULL)
+               return NULL;
+
        ret = mdiobus_read(bus, sw_addr + REG_PORT(0), 0x03);
        if (ret >= 0) {
                ret &= 0xfff0;
 
 #include <net/dsa.h>
 #include "mv88e6xxx.h"
 
-static char *mv88e6123_61_65_probe(struct mii_bus *bus, int sw_addr)
+static char *mv88e6123_61_65_probe(struct device *host_dev, int sw_addr)
 {
+       struct mii_bus *bus = dsa_host_dev_to_mii_bus(host_dev);
        int ret;
 
+       if (bus == NULL)
+               return NULL;
+
        ret = __mv88e6xxx_reg_read(bus, sw_addr, REG_PORT(0), 0x03);
        if (ret >= 0) {
                if (ret == 0x1212)
 
 #define ID_6095                0x0950
 #define ID_6131                0x1060
 
-static char *mv88e6131_probe(struct mii_bus *bus, int sw_addr)
+static char *mv88e6131_probe(struct device *host_dev, int sw_addr)
 {
+       struct mii_bus *bus = dsa_host_dev_to_mii_bus(host_dev);
        int ret;
 
+       if (bus == NULL)
+               return NULL;
+
        ret = __mv88e6xxx_reg_read(bus, sw_addr, REG_PORT(0), 0x03);
        if (ret >= 0) {
                ret &= 0xfff0;
 
 #include <net/dsa.h>
 #include "mv88e6xxx.h"
 
-static char *mv88e6171_probe(struct mii_bus *bus, int sw_addr)
+static char *mv88e6171_probe(struct device *host_dev, int sw_addr)
 {
+       struct mii_bus *bus = dsa_host_dev_to_mii_bus(host_dev);
        int ret;
 
+       if (bus == NULL)
+               return NULL;
+
        ret = __mv88e6xxx_reg_read(bus, sw_addr, REG_PORT(0), 0x03);
        if (ret >= 0) {
                if ((ret & 0xfff0) == 0x1710)
 
        int ret;
 
        mutex_lock(&ps->smi_mutex);
-       ret = __mv88e6xxx_reg_read(ds->master_mii_bus,
+       ret = __mv88e6xxx_reg_read(to_mii_bus(ds->master_dev),
                                   ds->pd->sw_addr, addr, reg);
        mutex_unlock(&ps->smi_mutex);
 
        int ret;
 
        mutex_lock(&ps->smi_mutex);
-       ret = __mv88e6xxx_reg_write(ds->master_mii_bus,
+       ret = __mv88e6xxx_reg_write(to_mii_bus(ds->master_dev),
                                    ds->pd->sw_addr, addr, reg, val);
        mutex_unlock(&ps->smi_mutex);
 
 
        /*
         * How to access the switch configuration registers.
         */
-       struct device   *mii_bus;
+       struct device   *host_dev;
        int             sw_addr;
 
        /* Device tree node pointer for this specific switch chip
        struct dsa_switch_driver        *drv;
 
        /*
-        * Reference to mii bus to use.
+        * Reference to host device to use.
         */
-       struct mii_bus          *master_mii_bus;
+       struct device           *master_dev;
 
        /*
         * Slave mii_bus and devices for the individual ports.
        /*
         * Probing and setup.
         */
-       char    *(*probe)(struct mii_bus *bus, int sw_addr);
+       char    *(*probe)(struct device *host_dev, int sw_addr);
        int     (*setup)(struct dsa_switch *ds);
        int     (*set_addr)(struct dsa_switch *ds, u8 *addr);
 
 
 void register_switch_driver(struct dsa_switch_driver *type);
 void unregister_switch_driver(struct dsa_switch_driver *type);
+struct mii_bus *dsa_host_dev_to_mii_bus(struct device *dev);
 
 static inline void *ds_to_priv(struct dsa_switch *ds)
 {
 
 EXPORT_SYMBOL_GPL(unregister_switch_driver);
 
 static struct dsa_switch_driver *
-dsa_switch_probe(struct mii_bus *bus, int sw_addr, char **_name)
+dsa_switch_probe(struct device *host_dev, int sw_addr, char **_name)
 {
        struct dsa_switch_driver *ret;
        struct list_head *list;
 
                drv = list_entry(list, struct dsa_switch_driver, list);
 
-               name = drv->probe(bus, sw_addr);
+               name = drv->probe(host_dev, sw_addr);
                if (name != NULL) {
                        ret = drv;
                        break;
 /* basic switch operations **************************************************/
 static struct dsa_switch *
 dsa_switch_setup(struct dsa_switch_tree *dst, int index,
-                struct device *parent, struct mii_bus *bus)
+                struct device *parent, struct device *host_dev)
 {
        struct dsa_chip_data *pd = dst->pd->chip + index;
        struct dsa_switch_driver *drv;
        /*
         * Probe for switch model.
         */
-       drv = dsa_switch_probe(bus, pd->sw_addr, &name);
+       drv = dsa_switch_probe(host_dev, pd->sw_addr, &name);
        if (drv == NULL) {
                printk(KERN_ERR "%s[%d]: could not detect attached switch\n",
                       dst->master_netdev->name, index);
        ds->index = index;
        ds->pd = dst->pd->chip + index;
        ds->drv = drv;
-       ds->master_mii_bus = bus;
-
+       ds->master_dev = host_dev;
 
        /*
         * Validate supplied switch configuration.
        return device_find_child(parent, class, dev_is_class);
 }
 
-static struct mii_bus *dev_to_mii_bus(struct device *dev)
+struct mii_bus *dsa_host_dev_to_mii_bus(struct device *dev)
 {
        struct device *d;
 
 
        return NULL;
 }
+EXPORT_SYMBOL_GPL(dsa_host_dev_to_mii_bus);
 
 static struct net_device *dev_to_net_device(struct device *dev)
 {
        dst->cpu_port = -1;
 
        for (i = 0; i < pd->nr_chips; i++) {
-               struct mii_bus *bus;
                struct dsa_switch *ds;
 
-               bus = dev_to_mii_bus(pd->chip[i].mii_bus);
-               if (bus == NULL) {
-                       printk(KERN_ERR "%s[%d]: no mii bus found for "
-                               "dsa switch\n", dev->name, i);
-                       continue;
-               }
-
-               ds = dsa_switch_setup(dst, i, &pdev->dev, bus);
+               ds = dsa_switch_setup(dst, i, &pdev->dev, pd->chip[i].host_dev);
                if (IS_ERR(ds)) {
                        printk(KERN_ERR "%s[%d]: couldn't create dsa switch "
                                "instance (error %ld)\n", dev->name, i,
 
        ds->slave_mii_bus->write = dsa_slave_phy_write;
        snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "dsa-%d:%.2x",
                        ds->index, ds->pd->sw_addr);
-       ds->slave_mii_bus->parent = &ds->master_mii_bus->dev;
+       ds->slave_mii_bus->parent = ds->master_dev;
 }