}
 
                if ((edev = DEVICE_EISA(gendev))) {
-                       print_name = edev->dev.bus_id;
+                       print_name = dev_name(&edev->dev);
                }
        }
 
                strcpy(info->bus_info, pci_name(VORTEX_PCI(vp)));
        } else {
                if (VORTEX_EISA(vp))
-                       sprintf(info->bus_info, vp->gendev->bus_id);
+                       sprintf(info->bus_info, dev_name(vp->gendev));
                else
                        sprintf(info->bus_info, "EISA 0x%lx %d",
                                        dev->base_addr, dev->irq);
 
        int dfx_bus_pci = DFX_BUS_PCI(bdev);
        int dfx_bus_tc = DFX_BUS_TC(bdev);
        int dfx_use_mmio = DFX_MMIO || dfx_bus_tc;
-       char *print_name = bdev->bus_id;
+       const char *print_name = dev_name(bdev);
        struct net_device *dev;
        DFX_board_t       *bp;                  /* board pointer */
        resource_size_t bar_start = 0;          /* pointer to port */
 
        strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
        strlcpy(info->version, DRV_VERSION, sizeof(info->version));
        strlcpy(info->bus_info,
-               dev->dev.parent->bus_id, sizeof(info->bus_info));
+               dev_name(dev->dev.parent), sizeof(info->bus_info));
 }
 
 static int
 
        struct phy_device *phydev;
        char phy_id[BUS_ID_SIZE];
 
-       snprintf(phy_id, BUS_ID_SIZE, "%x:%02x",
+       snprintf(phy_id, sizeof(phy_id), "%x:%02x",
                        (unsigned int)dev->base_addr, priv->phy_addr);
 
        priv->link = PHY_DOWN;
 
        priv->oldspeed = 0;
        priv->oldduplex = -1;
 
-       snprintf(phy_id, BUS_ID_SIZE, PHY_ID_FMT, priv->einfo->bus_id, priv->einfo->phy_id);
+       snprintf(phy_id, sizeof(phy_id), PHY_ID_FMT, priv->einfo->bus_id, priv->einfo->phy_id);
 
        interface = gfar_get_interface(dev);
 
 
 #define mlx4_dbg(mlevel, priv, format, arg...) \
        if (NETIF_MSG_##mlevel & priv->msg_enable) \
        printk(KERN_DEBUG "%s %s: " format , DRV_NAME ,\
-               (&priv->mdev->pdev->dev)->bus_id , ## arg)
+               (dev_name(&priv->mdev->pdev->dev)) , ## arg)
 
 #define mlx4_err(mdev, format, arg...) \
        printk(KERN_ERR "%s %s: " format , DRV_NAME ,\
-               (&mdev->pdev->dev)->bus_id , ## arg)
+               (dev_name(&mdev->pdev->dev)) , ## arg)
 #define mlx4_info(mdev, format, arg...) \
        printk(KERN_INFO "%s %s: " format , DRV_NAME ,\
-               (&mdev->pdev->dev)->bus_id , ## arg)
+               (dev_name(&mdev->pdev->dev)) , ## arg)
 #define mlx4_warn(mdev, format, arg...) \
        printk(KERN_WARNING "%s %s: " format , DRV_NAME ,\
-               (&mdev->pdev->dev)->bus_id , ## arg)
+               (dev_name(&mdev->pdev->dev)) , ## arg)
 
 /*
  * Device constants
 
                goto err;
 
        phy_id = *prop;
-       snprintf(mac->phy_id, BUS_ID_SIZE, "%x:%02x", (int)r.start, phy_id);
+       snprintf(mac->phy_id, sizeof(mac->phy_id), "%x:%02x",
+                (int)r.start, phy_id);
 
        of_node_put(phy_dn);
 
 
        bus->dev.parent = bus->parent;
        bus->dev.class = &mdio_bus_class;
        bus->dev.groups = NULL;
-       memcpy(bus->dev.bus_id, bus->id, MII_BUS_ID_SIZE);
+       dev_set_name(&bus->dev, bus->id);
 
        err = device_register(&bus->dev);
        if (err) {
 
        phydev->dev.parent = bus->parent;
        phydev->dev.bus = &mdio_bus_type;
-       snprintf(phydev->dev.bus_id, BUS_ID_SIZE, PHY_ID_FMT, bus->id, addr);
+       dev_set_name(&phydev->dev, PHY_ID_FMT, bus->id, addr);
 
        phydev->bus = bus;
 
 
  */
 void phy_print_status(struct phy_device *phydev)
 {
-       pr_info("PHY: %s - Link is %s", phydev->dev.bus_id,
+       pr_info("PHY: %s - Link is %s", dev_name(&phydev->dev),
                        phydev->link ? "Up" : "Down");
        if (phydev->link)
                printk(" - %d/%s", phydev->speed,
 
        if (!fixup)
                return -ENOMEM;
 
-       strncpy(fixup->bus_id, bus_id, BUS_ID_SIZE);
+       strlcpy(fixup->bus_id, bus_id, sizeof(fixup->bus_id));
        fixup->phy_uid = phy_uid;
        fixup->phy_uid_mask = phy_uid_mask;
        fixup->run = run;
  */
 static int phy_needs_fixup(struct phy_device *phydev, struct phy_fixup *fixup)
 {
-       if (strcmp(fixup->bus_id, phydev->dev.bus_id) != 0)
+       if (strcmp(fixup->bus_id, dev_name(&phydev->dev)) != 0)
                if (strcmp(fixup->bus_id, PHY_ANY_ID) != 0)
                        return 0;
 
 
        char phy_id[BUS_ID_SIZE];
        struct phy_device *phydev = NULL;
 
-       snprintf(phy_id, BUS_ID_SIZE, PHY_ID_FMT,
+       snprintf(phy_id, sizeof(phy_id), PHY_ID_FMT,
                mdp->mii_bus->id , mdp->phy_id);
 
        mdp->link = PHY_DOWN;
 
        phydev = tp->mdio_bus->phy_map[PHY_ADDR];
 
        /* Attach the MAC to the PHY. */
-       phydev = phy_connect(tp->dev, phydev->dev.bus_id, tg3_adjust_link,
+       phydev = phy_connect(tp->dev, dev_name(&phydev->dev), tg3_adjust_link,
                             phydev->dev_flags, phydev->interface);
        if (IS_ERR(phydev)) {
                printk(KERN_ERR "%s: Could not attach to PHY\n", tp->dev->name);
                       "%s: attached PHY driver [%s] (mii_bus:phy_addr=%s)\n",
                       tp->dev->name,
                       tp->mdio_bus->phy_map[PHY_ADDR]->drv->name,
-                      tp->mdio_bus->phy_map[PHY_ADDR]->dev.bus_id);
+                      dev_name(&tp->mdio_bus->phy_map[PHY_ADDR]->dev));
        else
                printk(KERN_INFO
                       "%s: attached PHY is %s (%s Ethernet) (WireSpeed[%d])\n",
 
     }
 
     dev->base_addr = iobase;
-    printk ("%s: %s at 0x%04lx", gendev->bus_id, name, iobase);
+    printk ("%s: %s at 0x%04lx", dev_name(gendev), name, iobase);
 
     status = get_hw_addr(dev);
     printk(", h/w address %pM\n", dev->dev_addr);
             }
         }
        lp->fdx = lp->params.fdx;
-       sprintf(lp->adapter_name,"%s (%s)", name, gendev->bus_id);
+       sprintf(lp->adapter_name,"%s (%s)", name, dev_name(gendev));
 
        lp->dma_size = (NUM_RX_DESC + NUM_TX_DESC) * sizeof(struct de4x5_desc);
 #if defined(__alpha__) || defined(__powerpc__) || defined(CONFIG_SPARC) || defined(DE4X5_DO_MEMCPY)
 
        priv->oldspeed = 0;
        priv->oldduplex = -1;
 
-       snprintf(phy_id, BUS_ID_SIZE, PHY_ID_FMT, priv->ug_info->mdio_bus,
-                       priv->ug_info->phy_address);
+       snprintf(phy_id, sizeof(phy_id), PHY_ID_FMT, priv->ug_info->mdio_bus,
+                priv->ug_info->phy_address);
 
        phydev = phy_connect(dev, phy_id, &adjust_link, 0, priv->phy_interface);
 
 
 #define lbs_deb_tx(fmt, args...)        LBS_DEB_LL(LBS_DEB_TX, " tx", fmt, ##args)
 #define lbs_deb_fw(fmt, args...)        LBS_DEB_LL(LBS_DEB_FW, " fw", fmt, ##args)
 #define lbs_deb_usb(fmt, args...)       LBS_DEB_LL(LBS_DEB_USB, " usb", fmt, ##args)
-#define lbs_deb_usbd(dev, fmt, args...) LBS_DEB_LL(LBS_DEB_USB, " usbd", "%s:" fmt, (dev)->bus_id, ##args)
+#define lbs_deb_usbd(dev, fmt, args...) LBS_DEB_LL(LBS_DEB_USB, " usbd", "%s:" fmt, dev_name(dev), ##args)
 #define lbs_deb_cs(fmt, args...)        LBS_DEB_LL(LBS_DEB_CS, " cs", fmt, ##args)
 #define lbs_deb_thread(fmt, args...)    LBS_DEB_LL(LBS_DEB_THREAD, " thread", fmt, ##args)
 #define lbs_deb_sdio(fmt, args...)      LBS_DEB_LL(LBS_DEB_SDIO, " sdio", fmt, ##args)
 
        strncpy(info->version, DRIVER_VERSION, sizeof(info->version) - 1);
        strncpy(info->fw_version, priv->fw_name, sizeof(info->fw_version) - 1);
        if (dev->dev.parent)
-               strncpy(info->bus_info, dev->dev.parent->bus_id,
+               strncpy(info->bus_info, dev_name(dev->dev.parent),
                        sizeof(info->bus_info) - 1);
        else
                snprintf(info->bus_info, sizeof(info->bus_info) - 1,
 
 
        /* Finally, report what we've done */
        printk(KERN_DEBUG "%s: " DRIVER_NAME " at %s, irq %d, io "
-              "0x%04x-0x%04x\n", dev->name, dev->dev.parent->bus_id,
+              "0x%04x-0x%04x\n", dev->name, dev_name(dev->dev.parent),
               link->irq.AssignedIRQ, link->io.BasePort1,
               link->io.BasePort1 + link->io.NumPorts1 - 1);
        return 0;
 
 
        /* Finally, report what we've done */
        printk(KERN_DEBUG "%s: " DRIVER_NAME " at %s, irq %d, io "
-              "0x%04x-0x%04x\n", dev->name, dev->dev.parent->bus_id,
+              "0x%04x-0x%04x\n", dev->name, dev_name(dev->dev.parent),
               link->irq.AssignedIRQ, link->io.BasePort1,
               link->io.BasePort1 + link->io.NumPorts1 - 1);
 
 
 /**
  * wiphy_name - get wiphy name
  */
-static inline char *wiphy_name(struct wiphy *wiphy)
+static inline const char *wiphy_name(struct wiphy *wiphy)
 {
-       return wiphy->dev.bus_id;
+       return dev_name(&wiphy->dev);
 }
 
 /**
 
        cdev->class = &atm_class;
        dev_set_drvdata(cdev, adev);
 
-       snprintf(cdev->bus_id, BUS_ID_SIZE, "%s%d", adev->type, adev->number);
+       dev_set_name(cdev, "%s%d", adev->type, adev->number);
        err = device_register(cdev);
        if (err < 0)
                return err;
 
        conn->dev.class = bt_class;
        conn->dev.parent = &hdev->dev;
 
-       snprintf(conn->dev.bus_id, BUS_ID_SIZE, "%s:%d",
-                                       hdev->name, conn->handle);
+       dev_set_name(&conn->dev, "%s:%d", hdev->name, conn->handle);
 
        dev_set_drvdata(&conn->dev, conn);
 
  */
 static int __match_tty(struct device *dev, void *data)
 {
-       return !strncmp(dev->bus_id, "rfcomm", 6);
+       return !strncmp(dev_name(dev), "rfcomm", 6);
 }
 
 static void del_conn(struct work_struct *work)
        dev->class = bt_class;
        dev->parent = hdev->parent;
 
-       strlcpy(dev->bus_id, hdev->name, BUS_ID_SIZE);
+       dev_set_name(dev, hdev->name);
 
        dev_set_drvdata(dev, hdev);
 
 
        dev->groups = groups;
 
        BUILD_BUG_ON(BUS_ID_SIZE < IFNAMSIZ);
-       strlcpy(dev->bus_id, net->name, BUS_ID_SIZE);
+       dev_set_name(dev, net->name);
 
 #ifdef CONFIG_SYSFS
        *groups++ = &netstat_group;
 
        netif_carrier_off(slave_dev);
 
        if (p->phy != NULL) {
-               phy_attach(slave_dev, p->phy->dev.bus_id,
+               phy_attach(slave_dev, dev_name(&p->phy->dev),
                           0, PHY_INTERFACE_MODE_GMII);
 
                p->phy->autoneg = AUTONEG_ENABLE;
 
        int error;
 
        if (!rfkill->led_trigger.name)
-               rfkill->led_trigger.name = rfkill->dev.bus_id;
+               rfkill->led_trigger.name = dev_name(&rfkill->dev);
        if (!rfkill->led_trigger.activate)
                rfkill->led_trigger.activate = rfkill_led_trigger_activate;
        error = led_trigger_register(&rfkill->led_trigger);
                        "badly initialized rfkill struct\n"))
                return -EINVAL;
 
-       snprintf(dev->bus_id, sizeof(dev->bus_id),
-                "rfkill%ld", (long)atomic_inc_return(&rfkill_no) - 1);
+       dev_set_name(dev, "rfkill%ld", (long)atomic_inc_return(&rfkill_no) - 1);
 
        rfkill_led_trigger_register(rfkill);
 
 
        mutex_unlock(&cfg80211_drv_mutex);
 
        /* give it a proper name */
-       snprintf(drv->wiphy.dev.bus_id, BUS_ID_SIZE,
-                PHY_NAME "%d", drv->idx);
+       dev_set_name(&drv->wiphy.dev, PHY_NAME "%d", drv->idx);
 
        mutex_init(&drv->mtx);
        mutex_init(&drv->devlist_mtx);