struct bttv_sub_driver *sub = to_bttv_sub_drv(drv);
        int len = strlen(sub->wanted);
 
-       if (0 == strncmp(dev->bus_id, sub->wanted, len))
+       if (0 == strncmp(dev_name(dev), sub->wanted, len))
                return 1;
        return 0;
 }
        sub->dev.parent  = &core->pci->dev;
        sub->dev.bus     = &bttv_sub_bus_type;
        sub->dev.release = release_sub_device;
-       snprintf(sub->dev.bus_id,sizeof(sub->dev.bus_id),"%s%d",
-                name, core->nr);
+       dev_set_name(&sub->dev, "%s%d", name, core->nr);
 
        err = device_register(&sub->dev);
        if (0 != err) {
                kfree(sub);
                return err;
        }
-       printk("bttv%d: add subdevice \"%s\"\n", core->nr, sub->dev.bus_id);
+       printk("bttv%d: add subdevice \"%s\"\n", core->nr, dev_name(&sub->dev));
        list_add_tail(&sub->list,&core->subs);
        return 0;
 }
 
 
 struct bttv_sub_driver {
        struct device_driver   drv;
-       char                   wanted[BUS_ID_SIZE];
+       char                   wanted[20];
        int                    (*probe)(struct bttv_sub_device *sub);
        void                   (*remove)(struct bttv_sub_device *sub);
 };
 
 
        strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
        strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
-       strlcpy(cap->bus_info, dev->udev->dev.bus_id, sizeof(cap->bus_info));
+       strlcpy(cap->bus_info, dev_name(&dev->udev->dev), sizeof(cap->bus_info));
 
        cap->version = EM28XX_VERSION_CODE;
 
 
        strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
        strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
-       strlcpy(cap->bus_info, dev->udev->dev.bus_id, sizeof(cap->bus_info));
+       strlcpy(cap->bus_info, dev_name(&dev->udev->dev), sizeof(cap->bus_info));
 
        cap->version = EM28XX_VERSION_CODE;
        cap->capabilities = V4L2_CAP_TUNER;
 
 
        strlcpy(cap.card, cam->v4ldev->name, sizeof(cap.card));
        if (usb_make_path(cam->usbdev, cap.bus_info, sizeof(cap.bus_info)) < 0)
-               strlcpy(cap.bus_info, cam->usbdev->dev.bus_id,
+               strlcpy(cap.bus_info, dev_name(&cam->usbdev->dev),
                        sizeof(cap.bus_info));
 
        if (copy_to_user(arg, &cap, sizeof(cap)))
 
                goto err_out_detach;
        }
 
-       /* Phys addr can only be set after attaching (for ir->c.dev.bus_id) */
+       /* Phys addr can only be set after attaching (for ir->c.dev) */
        snprintf(ir->phys, sizeof(ir->phys), "%s/%s/ir0",
-                ir->c.adapter->dev.bus_id,
-                ir->c.dev.bus_id);
+                dev_name(&ir->c.adapter->dev),
+                dev_name(&ir->c.dev));
 
        /* init + register input device */
        ir_input_init(input_dev, &ir->ir, ir_type, ir->ir_codes);
 
 
        scnprintf(hdw->bus_info,sizeof(hdw->bus_info),
                  "usb %s address %d",
-                 hdw->usb_dev->dev.bus_id,
+                 dev_name(&hdw->usb_dev->dev),
                  hdw->usb_dev->devnum);
 
        ifnum = hdw->usb_intf->cur_altsetting->desc.bInterfaceNumber;
 
 
        class_dev->class = &class_ptr->class;
        if (pvr2_hdw_get_sn(sfp->channel.hdw)) {
-               snprintf(class_dev->bus_id, BUS_ID_SIZE, "sn-%lu",
+               dev_set_name(class_dev, "sn-%lu",
                         pvr2_hdw_get_sn(sfp->channel.hdw));
        } else if (pvr2_hdw_get_unit_number(sfp->channel.hdw) >= 0) {
-               snprintf(class_dev->bus_id, BUS_ID_SIZE, "unit-%c",
+               dev_set_name(class_dev, "unit-%c",
                         pvr2_hdw_get_unit_number(sfp->channel.hdw) + 'a');
        } else {
                kfree(class_dev);
 
 
        /* request irq */
        err = request_irq(pcdev->irq, sh_mobile_ceu_irq, IRQF_DISABLED,
-                         pdev->dev.bus_id, pcdev);
+                         dev_name(&pdev->dev), pcdev);
        if (err) {
                dev_err(&pdev->dev, "Unable to register CEU interrupt.\n");
                goto exit_release_mem;
        pcdev->ici.priv = pcdev;
        pcdev->ici.dev.parent = &pdev->dev;
        pcdev->ici.nr = pdev->id;
-       pcdev->ici.drv_name = pdev->dev.bus_id,
-       pcdev->ici.ops = &sh_mobile_ceu_host_ops,
+       pcdev->ici.drv_name = dev_name(&pdev->dev);
+       pcdev->ici.ops = &sh_mobile_ceu_host_ops;
 
        err = soc_camera_host_register(&pcdev->ici);
        if (err)
 
 
        strlcpy(cap.card, cam->v4ldev->name, sizeof(cap.card));
        if (usb_make_path(cam->usbdev, cap.bus_info, sizeof(cap.bus_info)) < 0)
-               strlcpy(cap.bus_info, cam->usbdev->dev.bus_id,
+               strlcpy(cap.bus_info, dev_name(&cam->usbdev->dev),
                        sizeof(cap.bus_info));
 
        if (copy_to_user(arg, &cap, sizeof(cap)))
 
                return -EINVAL;
 
        /* Number might be equal to the platform device ID */
-       sprintf(ici->dev.bus_id, "camera_host%d", ici->nr);
+       dev_set_name(&ici->dev, "camera_host%d", ici->nr);
 
        mutex_lock(&list_lock);
        list_for_each_entry(ix, &hosts, list) {
 
        icd->devnum = num;
        icd->dev.bus = &soc_camera_bus_type;
-       snprintf(icd->dev.bus_id, sizeof(icd->dev.bus_id),
-                "%u-%u", icd->iface, icd->devnum);
+       dev_set_name(&icd->dev, "%u-%u", icd->iface, icd->devnum);
 
        icd->dev.release = dummy_release;
 
 
        strlcpy(vc->card,
                usbvision_device_data[usbvision->DevModel].ModelString,
                sizeof(vc->card));
-       strlcpy(vc->bus_info, usbvision->dev->dev.bus_id,
+       strlcpy(vc->bus_info, dev_name(&usbvision->dev->dev),
                sizeof(vc->bus_info));
        vc->version = USBVISION_DRIVER_VERSION;
        vc->capabilities = V4L2_CAP_VIDEO_CAPTURE |
 
        vfd->dev.devt = MKDEV(VIDEO_MAJOR, vfd->minor);
        if (vfd->parent)
                vfd->dev.parent = vfd->parent;
-       sprintf(vfd->dev.bus_id, "%s%d", name_base, nr);
+       dev_set_name(&vfd->dev, "%s%d", name_base, nr);
        ret = device_register(&vfd->dev);
        if (ret < 0) {
                printk(KERN_ERR "%s: device_register failed\n", __func__);
 
 
        strlcpy(cap.card, cam->v4ldev->name, sizeof(cap.card));
        if (usb_make_path(cam->usbdev, cap.bus_info, sizeof(cap.bus_info)) < 0)
-               strlcpy(cap.bus_info, cam->usbdev->dev.bus_id,
+               strlcpy(cap.bus_info, dev_name(&cam->usbdev->dev),
                        sizeof(cap.bus_info));
 
        if (copy_to_user(arg, &cap, sizeof(cap)))
 
        struct device dev;
        unsigned char nr;                               /* Host number */
        void *priv;
-       char *drv_name;
+       const char *drv_name;
        struct soc_camera_host_ops *ops;
 };
 
 extern void soc_camera_video_stop(struct soc_camera_device *icd);
 
 struct soc_camera_data_format {
-       char *name;
+       const char *name;
        unsigned int depth;
        __u32 fourcc;
        enum v4l2_colorspace colorspace;