static int erase_chip(struct m25p *flash)
 {
        DEBUG(MTD_DEBUG_LEVEL3, "%s: %s %lldKiB\n",
-                       flash->spi->dev.bus_id, __func__,
-                       (long long)(flash->mtd.size >> 10));
+             dev_name(&flash->spi->dev), __func__,
+             (long long)(flash->mtd.size >> 10));
 
        /* Wait until finished previous write command. */
        if (wait_till_ready(flash))
 static int erase_sector(struct m25p *flash, u32 offset)
 {
        DEBUG(MTD_DEBUG_LEVEL3, "%s: %s %dKiB at 0x%08x\n",
-                       flash->spi->dev.bus_id, __func__,
+                       dev_name(&flash->spi->dev), __func__,
                        flash->mtd.erasesize / 1024, offset);
 
        /* Wait until finished previous write command. */
        uint32_t rem;
 
        DEBUG(MTD_DEBUG_LEVEL2, "%s: %s %s 0x%llx, len %lld\n",
-                       flash->spi->dev.bus_id, __func__, "at",
-                       (long long)instr->addr, (long long)instr->len);
+             dev_name(&flash->spi->dev), __func__, "at",
+             (long long)instr->addr, (long long)instr->len);
 
        /* sanity checks */
        if (instr->addr + instr->len > flash->mtd.size)
        struct spi_message m;
 
        DEBUG(MTD_DEBUG_LEVEL2, "%s: %s %s 0x%08x, len %zd\n",
-                       flash->spi->dev.bus_id, __func__, "from",
+                       dev_name(&flash->spi->dev), __func__, "from",
                        (u32)from, len);
 
        /* sanity checks */
        struct spi_message m;
 
        DEBUG(MTD_DEBUG_LEVEL2, "%s: %s %s 0x%08x, len %zd\n",
-                       flash->spi->dev.bus_id, __func__, "to",
+                       dev_name(&flash->spi->dev), __func__, "to",
                        (u32)to, len);
 
        if (retlen)
        tmp = spi_write_then_read(spi, &code, 1, id, 5);
        if (tmp < 0) {
                DEBUG(MTD_DEBUG_LEVEL0, "%s: error %d reading JEDEC ID\n",
-                       spi->dev.bus_id, tmp);
+                       dev_name(&spi->dev), tmp);
                return NULL;
        }
        jedec = id[0];
                /* unrecognized chip? */
                if (i == ARRAY_SIZE(m25p_data)) {
                        DEBUG(MTD_DEBUG_LEVEL0, "%s: unrecognized id %s\n",
-                                       spi->dev.bus_id, data->type);
+                                       dev_name(&spi->dev), data->type);
                        info = NULL;
 
                /* recognized; is that chip really what's there? */
        if (data && data->name)
                flash->mtd.name = data->name;
        else
-               flash->mtd.name = spi->dev.bus_id;
+               flash->mtd.name = dev_name(&spi->dev);
 
        flash->mtd.type = MTD_NORFLASH;
        flash->mtd.writesize = 1;
 
                status = dataflash_status(spi);
                if (status < 0) {
                        DEBUG(MTD_DEBUG_LEVEL1, "%s: status %d?\n",
-                                       spi->dev.bus_id, status);
+                                       dev_name(&spi->dev), status);
                        status = 0;
                }
 
        uint32_t                rem;
 
        DEBUG(MTD_DEBUG_LEVEL2, "%s: erase addr=0x%llx len 0x%llx\n",
-                       spi->dev.bus_id, (long long)instr->addr,
-                       (long long)instr->len);
+             dev_name(&spi->dev), (long long)instr->addr,
+             (long long)instr->len);
 
        /* Sanity checks */
        if (instr->addr + instr->len > mtd->size)
 
                if (status < 0) {
                        printk(KERN_ERR "%s: erase %x, err %d\n",
-                               spi->dev.bus_id, pageaddr, status);
+                               dev_name(&spi->dev), pageaddr, status);
                        /* REVISIT:  can retry instr->retries times; or
                         * giveup and instr->fail_addr = instr->addr;
                         */
        int                     status;
 
        DEBUG(MTD_DEBUG_LEVEL2, "%s: read 0x%x..0x%x\n",
-               priv->spi->dev.bus_id, (unsigned)from, (unsigned)(from + len));
+               dev_name(&priv->spi->dev), (unsigned)from, (unsigned)(from + len));
 
        *retlen = 0;
 
                status = 0;
        } else
                DEBUG(MTD_DEBUG_LEVEL1, "%s: read %x..%x --> %d\n",
-                       priv->spi->dev.bus_id,
+                       dev_name(&priv->spi->dev),
                        (unsigned)from, (unsigned)(from + len),
                        status);
        return status;
        uint8_t                 *command;
 
        DEBUG(MTD_DEBUG_LEVEL2, "%s: write 0x%x..0x%x\n",
-               spi->dev.bus_id, (unsigned)to, (unsigned)(to + len));
+               dev_name(&spi->dev), (unsigned)to, (unsigned)(to + len));
 
        *retlen = 0;
 
                        status = spi_sync(spi, &msg);
                        if (status < 0)
                                DEBUG(MTD_DEBUG_LEVEL1, "%s: xfer %u -> %d \n",
-                                       spi->dev.bus_id, addr, status);
+                                       dev_name(&spi->dev), addr, status);
 
                        (void) dataflash_waitready(priv->spi);
                }
                spi_transfer_del(x + 1);
                if (status < 0)
                        DEBUG(MTD_DEBUG_LEVEL1, "%s: pgm %u/%u -> %d \n",
-                               spi->dev.bus_id, addr, writelen, status);
+                               dev_name(&spi->dev), addr, writelen, status);
 
                (void) dataflash_waitready(priv->spi);
 
                status = spi_sync(spi, &msg);
                if (status < 0)
                        DEBUG(MTD_DEBUG_LEVEL1, "%s: compare %u -> %d \n",
-                               spi->dev.bus_id, addr, status);
+                               dev_name(&spi->dev), addr, status);
 
                status = dataflash_waitready(priv->spi);
 
                /* Check result of the compare operation */
                if (status & (1 << 6)) {
                        printk(KERN_ERR "%s: compare page %u, err %d\n",
-                               spi->dev.bus_id, pageaddr, status);
+                               dev_name(&spi->dev), pageaddr, status);
                        remaining = 0;
                        status = -EIO;
                        break;
        tmp = spi_write_then_read(spi, &code, 1, id, 3);
        if (tmp < 0) {
                DEBUG(MTD_DEBUG_LEVEL0, "%s: error %d reading JEDEC ID\n",
-                       spi->dev.bus_id, tmp);
+                       dev_name(&spi->dev), tmp);
                return ERR_PTR(tmp);
        }
        if (id[0] != 0x1f)
        status = dataflash_status(spi);
        if (status <= 0 || status == 0xff) {
                DEBUG(MTD_DEBUG_LEVEL1, "%s: status error %d\n",
-                               spi->dev.bus_id, status);
+                               dev_name(&spi->dev), status);
                if (status == 0 || status == 0xff)
                        status = -ENODEV;
                return status;
        /* obsolete AT45DB1282 not (yet?) supported */
        default:
                DEBUG(MTD_DEBUG_LEVEL1, "%s: unsupported device (%x)\n",
-                               spi->dev.bus_id, status & 0x3c);
+                               dev_name(&spi->dev), status & 0x3c);
                status = -ENODEV;
        }
 
        if (status < 0)
                DEBUG(MTD_DEBUG_LEVEL1, "%s: add_dataflash --> %d\n",
-                               spi->dev.bus_id, status);
+                               dev_name(&spi->dev), status);
 
        return status;
 }
        struct dataflash        *flash = dev_get_drvdata(&spi->dev);
        int                     status;
 
-       DEBUG(MTD_DEBUG_LEVEL1, "%s: remove\n", spi->dev.bus_id);
+       DEBUG(MTD_DEBUG_LEVEL1, "%s: remove\n", dev_name(&spi->dev));
 
        if (mtd_has_partitions() && flash->partitioned)
                status = del_mtd_partitions(&flash->mtd);
 
        info->map.bankwidth     = plat->width;
        info->map.phys          = res->start;
        info->map.virt          = base;
-       info->map.name          = dev->dev.bus_id;
+       info->map.name          = dev_name(&dev->dev);
        info->map.set_vpp       = armflash_set_vpp;
 
        simple_map_init(&info->map);
 
         */
        info->map.map_priv_2 = (unsigned long) ixp_data->bank_setup;
 
-       info->map.name = dev->dev.bus_id;
+       info->map.name = dev_name(&dev->dev);
        info->map.read = ixp2000_flash_read8;
        info->map.write = ixp2000_flash_write8;
        info->map.copy_from = ixp2000_flash_copy_from;
 
        info->res = request_mem_region(dev->resource->start,
                        dev->resource->end - dev->resource->start + 1,
-                       dev->dev.bus_id);
+                       dev_name(&dev->dev));
        if (!info->res) {
                dev_err(&dev->dev, "Could not reserve memory region\n");
                err = -ENOMEM;
 
         * handle that.
         */
        info->map.bankwidth = 2;
-       info->map.name = dev->dev.bus_id;
+       info->map.name = dev_name(&dev->dev);
        info->map.read = ixp4xx_read16,
        info->map.write = ixp4xx_probe_write16,
        info->map.copy_from = ixp4xx_copy_from,
 
                err = -ENOMEM;
                goto out_release_mem_region;
        }
-       info->map.name          = pdev->dev.bus_id;
+       info->map.name          = dev_name(&pdev->dev);
        info->map.phys          = res->start;
        info->map.size          = size;
        info->map.bankwidth     = pdata->width;
 
                if (!devm_request_mem_region(&dev->dev,
                        dev->resource[i].start,
                        dev->resource[i].end - dev->resource[i].start + 1,
-                       dev->dev.bus_id)) {
+                       dev_name(&dev->dev))) {
                        dev_err(&dev->dev, "Could not reserve memory region\n");
                        err = -ENOMEM;
                        goto err_out;
                }
 
-               info->map[i].name = dev->dev.bus_id;
+               info->map[i].name = dev_name(&dev->dev);
                info->map[i].phys = dev->resource[i].start;
                info->map[i].size = dev->resource[i].end - dev->resource[i].start + 1;
                info->map[i].bankwidth = physmap_data->width;
                 * We detected multiple devices. Concatenate them together.
                 */
 #ifdef CONFIG_MTD_CONCAT
-               info->cmtd = mtd_concat_create(info->mtd, devices_found, dev->dev.bus_id);
+               info->cmtd = mtd_concat_create(info->mtd, devices_found, dev_name(&dev->dev));
                if (info->cmtd == NULL)
                        err = -ENXIO;
 #else
 
 
        err = -EBUSY;
        info->res = request_mem_region(res.start, res.end - res.start + 1,
-                                      dev->dev.bus_id);
+                                      dev_name(&dev->dev));
        if (!info->res)
                goto err_out;
 
                goto err_out;
        }
 
-       info->map.name = dev->dev.bus_id;
+       info->map.name = dev_name(&dev->dev);
        info->map.phys = res.start;
        info->map.size = res.end - res.start + 1;
        info->map.bankwidth = *width;
 
  */
 struct mtd_info *mtd_concat_create(struct mtd_info *subdev[],  /* subdevices to concatenate */
                                   int num_devs,        /* number of subdevices      */
-                                  char *name)
+                                  const char *name)
 {                              /* name for the new device   */
        int i;
        size_t size;
 
 
        fun->rnb_gpio = of_get_gpio(ofdev->node, 0);
        if (fun->rnb_gpio >= 0) {
-               ret = gpio_request(fun->rnb_gpio, ofdev->dev.bus_id);
+               ret = gpio_request(fun->rnb_gpio, dev_name(&ofdev->dev));
                if (ret) {
                        dev_err(&ofdev->dev, "can't request RNB gpio\n");
                        goto err2;
 
        data->chip.priv = &data;
        data->mtd.priv = &data->chip;
        data->mtd.owner = THIS_MODULE;
-       data->mtd.name = pdev->dev.bus_id;
+       data->mtd.name = dev_name(&pdev->dev);
 
        data->chip.IO_ADDR_R = data->io_base;
        data->chip.IO_ADDR_W = data->io_base;
 
        nand_chip->chip_delay = 15;
 
        retval = request_irq(irq, &tmio_irq,
-                               IRQF_DISABLED, dev->dev.bus_id, tmio);
+                               IRQF_DISABLED, dev_name(&dev->dev), tmio);
        if (retval) {
                dev_err(&dev->dev, "request_irq error %d\n", retval);
                goto err_irq;
 
        info->onenand.mmcontrol = pdata->mmcontrol;
        info->onenand.irq = platform_get_irq(pdev, 0);
 
-       info->mtd.name = pdev->dev.bus_id;
+       info->mtd.name = dev_name(&pdev->dev);
        info->mtd.priv = &info->onenand;
        info->mtd.owner = THIS_MODULE;
 
 
                 c->onenand.base);
 
        c->pdev = pdev;
-       c->mtd.name = pdev->dev.bus_id;
+       c->mtd.name = dev_name(&pdev->dev);
        c->mtd.priv = &c->onenand;
        c->mtd.owner = THIS_MODULE;
 
 
        ubi->dev.release = dev_release;
        ubi->dev.devt = ubi->cdev.dev;
        ubi->dev.class = ubi_class;
-       sprintf(&ubi->dev.bus_id[0], UBI_NAME_STR"%d", ubi->ubi_num);
+       dev_set_name(&ubi->dev, UBI_NAME_STR"%d", ubi->ubi_num);
        err = device_register(&ubi->dev);
        if (err)
                return err;
 
        vol->dev.devt = dev;
        vol->dev.class = ubi_class;
 
-       sprintf(&vol->dev.bus_id[0], "%s_%d", ubi->ubi_name, vol->vol_id);
+       dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id);
        err = device_register(&vol->dev);
        if (err) {
                ubi_err("cannot register device");
        vol->dev.parent = &ubi->dev;
        vol->dev.devt = dev;
        vol->dev.class = ubi_class;
-       sprintf(&vol->dev.bus_id[0], "%s_%d", ubi->ubi_name, vol->vol_id);
+       dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id);
        err = device_register(&vol->dev);
        if (err)
                goto out_gluebi;
 
 struct mtd_info *mtd_concat_create(
     struct mtd_info *subdev[],  /* subdevices to concatenate */
     int num_devs,               /* number of subdevices      */
-    char *name);                /* name for the new device   */
+    const char *name);          /* name for the new device   */
 
 void mtd_concat_destroy(struct mtd_info *mtd);