nvbios_M0203Em(struct nvkm_bios *bios, u8 ramcfg, u8 *ver, u8 *hdr,
               struct nvbios_M0203E *info)
 {
+       struct nvkm_subdev *subdev = &bios->subdev;
        struct nvbios_M0203T M0203T;
        u8  cnt, len, idx = 0xff;
        u32 data;
 
        if (!nvbios_M0203Tp(bios, ver, hdr, &cnt, &len, &M0203T)) {
-               nv_warn(bios, "M0203T not found\n");
+               nvkm_warn(subdev, "M0203T not found\n");
                return 0x00000000;
        }
 
                                continue;
                        return data;
                default:
-                       nv_warn(bios, "M0203T type %02x\n", M0203T.type);
+                       nvkm_warn(subdev, "M0203T type %02x\n", M0203T.type);
                        return 0x00000000;
                }
        }
 
        bios->bmp_offset = nvbios_findstr(bios->data, bios->size,
                                          "\xff\x7f""NV\0", 5);
        if (bios->bmp_offset) {
-               nv_info(bios, "BMP version %x.%x\n",
-                       bmp_version(bios) >> 8,
-                       bmp_version(bios) & 0xff);
+               nvkm_debug(&bios->subdev, "BMP version %x.%x\n",
+                          bmp_version(bios) >> 8,
+                          bmp_version(bios) & 0xff);
        }
 
        bios->bit_offset = nvbios_findstr(bios->data, bios->size,
                                          "\xff\xb8""BIT", 5);
        if (bios->bit_offset)
-               nv_info(bios, "BIT signature found\n");
+               nvkm_debug(&bios->subdev, "BIT signature found\n");
 
        /* determine the vbios version number */
        if (!bit_entry(bios, 'i', &bit_i) && bit_i.length >= 4) {
                bios->version.micro = nv_ro08(bios, bios->bmp_offset + 10);
        }
 
-       nv_info(bios, "version %02x.%02x.%02x.%02x.%02x\n",
-               bios->version.major, bios->version.chip,
-               bios->version.minor, bios->version.micro, bios->version.patch);
-
+       nvkm_info(&bios->subdev, "version %02x.%02x.%02x.%02x.%02x\n",
+                 bios->version.major, bios->version.chip,
+                 bios->version.minor, bios->version.micro, bios->version.patch);
        return 0;
 }
 
 
 u16
 dcb_table(struct nvkm_bios *bios, u8 *ver, u8 *hdr, u8 *cnt, u8 *len)
 {
-       struct nvkm_device *device = nv_device(bios);
+       struct nvkm_subdev *subdev = &bios->subdev;
+       struct nvkm_device *device = subdev->device;
        u16 dcb = 0x0000;
 
        if (device->card_type > NV_04)
                dcb = nv_ro16(bios, 0x36);
        if (!dcb) {
-               nv_warn(bios, "DCB table not found\n");
+               nvkm_warn(subdev, "DCB table not found\n");
                return dcb;
        }
 
        *ver = nv_ro08(bios, dcb);
 
        if (*ver >= 0x42) {
-               nv_warn(bios, "DCB version 0x%02x unknown\n", *ver);
+               nvkm_warn(subdev, "DCB version 0x%02x unknown\n", *ver);
                return 0x0000;
        } else
        if (*ver >= 0x30) {
                 *
                 * v1.1 (NV5+, maybe some NV4) is entirely unhelpful
                 */
-               nv_warn(bios, "DCB contains no useful data\n");
+               nvkm_debug(subdev, "DCB contains no useful data\n");
                return 0x0000;
        }
 
-       nv_warn(bios, "DCB header validation failed\n");
+       nvkm_warn(subdev, "DCB header validation failed\n");
        return 0x0000;
 }
 
 
        }
 
        if (i2c && *ver >= 0x42) {
-               nv_warn(bios, "ccb %02x not supported\n", *ver);
+               nvkm_warn(&bios->subdev, "ccb %02x not supported\n", *ver);
                return 0x0000;
        }
 
 int
 dcb_i2c_parse(struct nvkm_bios *bios, u8 idx, struct dcb_i2c_entry *info)
 {
+       struct nvkm_subdev *subdev = &bios->subdev;
        u8  ver, len;
        u16 ent = dcb_i2c_entry(bios, idx, &ver, &len);
        if (ent) {
                case DCB_I2C_UNUSED:
                        return 0;
                default:
-                       nv_warn(bios, "unknown i2c type %d\n", info->type);
+                       nvkm_warn(subdev, "unknown i2c type %d\n", info->type);
                        info->type = DCB_I2C_UNUSED;
                        return 0;
                }
 
 static bool
 nvbios_imagen(struct nvkm_bios *bios, struct nvbios_image *image)
 {
+       struct nvkm_subdev *subdev = &bios->subdev;
        struct nvbios_pcirT pcir;
        struct nvbios_npdeT npde;
        u8  ver;
        case 0x4e56: /* NV */
                break;
        default:
-               nv_debug(bios, "%08x: ROM signature (%04x) unknown\n",
-                        image->base, data);
+               nvkm_debug(subdev, "%08x: ROM signature (%04x) unknown\n",
+                          image->base, data);
                return false;
        }
 
 
 #include <subdev/vga.h>
 
 #define bioslog(lvl, fmt, args...) do {                                        \
-       nv_printk(init->bios, lvl, "0x%04x[%c]: "fmt, init->offset,            \
-                 init_exec(init) ? '0' + (init->nested - 1) : ' ', ##args);   \
+       nvkm_printk(init->subdev, lvl, info, "0x%04x[%c]: "fmt,                \
+                   init->offset, init_exec(init) ?                            \
+                   '0' + (init->nested - 1) : ' ', ##args);                   \
 } while(0)
 #define cont(fmt, args...) do {                                                \
-       if (nv_subdev(init->bios)->debug >= NV_DBG_TRACE)                      \
+       if (init->subdev->debug >= NV_DBG_TRACE)                               \
                printk(fmt, ##args);                                           \
 } while(0)
 #define trace(fmt, args...) bioslog(TRACE, fmt, ##args)
        u16 data;
 
        if (execute)
-               nv_info(bios, "running init tables\n");
+               nvkm_debug(subdev, "running init tables\n");
        while (!ret && (data = (init_script(bios, ++i)))) {
                struct nvbios_init init = {
                        .subdev = subdev,
 
 u16
 mxm_table(struct nvkm_bios *bios, u8 *ver, u8 *hdr)
 {
+       struct nvkm_subdev *subdev = &bios->subdev;
        struct bit_entry x;
 
        if (bit_entry(bios, 'x', &x)) {
-               nv_debug(bios, "BIT 'x' table not present\n");
+               nvkm_debug(subdev, "BIT 'x' table not present\n");
                return 0x0000;
        }
 
        *ver = x.version;
        *hdr = x.length;
        if (*ver != 1 || *hdr < 3) {
-               nv_warn(bios, "BIT 'x' table %d/%d unknown\n", *ver, *hdr);
+               nvkm_warn(subdev, "BIT 'x' table %d/%d unknown\n", *ver, *hdr);
                return 0x0000;
        }
 
 u8
 mxm_sor_map(struct nvkm_bios *bios, u8 conn)
 {
+       struct nvkm_subdev *subdev = &bios->subdev;
        u8  ver, hdr;
        u16 mxm = mxm_table(bios, &ver, &hdr);
        if (mxm && hdr >= 6) {
                                return 0x00;
                        }
 
-                       nv_warn(bios, "unknown sor map v%02x\n", ver);
+                       nvkm_warn(subdev, "unknown sor map v%02x\n", ver);
                }
        }
 
        if (bios->version.chip == 0x98)
                return g98_sor_map[conn];
 
-       nv_warn(bios, "missing sor map\n");
+       nvkm_warn(subdev, "missing sor map\n");
        return 0x00;
 }
 
 u8
 mxm_ddc_map(struct nvkm_bios *bios, u8 port)
 {
+       struct nvkm_subdev *subdev = &bios->subdev;
        u8  ver, hdr;
        u16 mxm = mxm_table(bios, &ver, &hdr);
        if (mxm && hdr >= 8) {
                                return 0x00;
                        }
 
-                       nv_warn(bios, "unknown ddc map v%02x\n", ver);
+                       nvkm_warn(subdev, "unknown ddc map v%02x\n", ver);
                }
        }
 
 
                case 0x4544504e: /* NPDE */
                        break;
                default:
-                       nv_debug(bios, "%08x: NPDE signature (%08x) unknown\n",
-                                data, nv_ro32(bios, data + 0x00));
+                       nvkm_debug(&bios->subdev,
+                                  "%08x: NPDE signature (%08x) unknown\n",
+                                  data, nv_ro32(bios, data + 0x00));
                        data = 0;
                        break;
                }
 
                        *ver = nv_ro08(bios, data + 0x0c);
                        break;
                default:
-                       nv_debug(bios, "%08x: PCIR signature (%08x) unknown\n",
-                                data, nv_ro32(bios, data + 0x00));
+                       nvkm_debug(&bios->subdev,
+                                  "%08x: PCIR signature (%08x) unknown\n",
+                                  data, nv_ro32(bios, data + 0x00));
                        data = 0;
                        break;
                }
 
 int
 nvbios_pll_parse(struct nvkm_bios *bios, u32 type, struct nvbios_pll *info)
 {
-       struct nvkm_device *device = bios->subdev.device;
+       struct nvkm_subdev *subdev = &bios->subdev;
+       struct nvkm_device *device = subdev->device;
        u8  ver, len;
        u32 reg = type;
        u16 data;
                info->max_p = nv_ro08(bios, data + 13);
                break;
        default:
-               nv_error(bios, "unknown pll limits version 0x%02x\n", ver);
+               nvkm_error(subdev, "unknown pll limits version 0x%02x\n", ver);
                return -EINVAL;
        }
 
 
 static int
 shadow_image(struct nvkm_bios *bios, int idx, struct shadow *mthd)
 {
+       struct nvkm_subdev *subdev = &bios->subdev;
        struct nvbios_image image;
        int score = 1;
 
        if (!nvbios_image(bios, idx, &image)) {
-               nv_debug(bios, "image %d invalid\n", idx);
+               nvkm_debug(subdev, "image %d invalid\n", idx);
                return 0;
        }
-       nv_debug(bios, "%08x: type %02x, %d bytes\n",
-                image.base, image.type, image.size);
+       nvkm_debug(subdev, "%08x: type %02x, %d bytes\n",
+                  image.base, image.type, image.size);
 
        if (!shadow_fetch(bios, image.size)) {
-               nv_debug(bios, "%08x: fetch failed\n", image.base);
+               nvkm_debug(subdev, "%08x: fetch failed\n", image.base);
                return 0;
        }
 
        switch (image.type) {
        case 0x00:
                if (nvbios_checksum(&bios->data[image.base], image.size)) {
-                       nv_debug(bios, "%08x: checksum failed\n", image.base);
+                       nvkm_debug(subdev, "%08x: checksum failed\n",
+                                  image.base);
                        if (mthd->func->rw)
                                score += 1;
                        score += 1;
 shadow_method(struct nvkm_bios *bios, struct shadow *mthd, const char *name)
 {
        const struct nvbios_source *func = mthd->func;
+       struct nvkm_subdev *subdev = &bios->subdev;
        if (func->name) {
-               nv_debug(bios, "trying %s...\n", name ? name : func->name);
+               nvkm_debug(subdev, "trying %s...\n", name ? name : func->name);
                if (func->init) {
                        mthd->data = func->init(bios, name);
                        if (IS_ERR(mthd->data)) {
                mthd->score = shadow_score(bios, mthd);
                if (func->fini)
                        func->fini(mthd->data);
-               nv_debug(bios, "scored %d\n", mthd->score);
+               nvkm_debug(subdev, "scored %d\n", mthd->score);
                mthd->data = bios->data;
                mthd->size = bios->size;
                bios->data  = NULL;
 int
 nvbios_shadow(struct nvkm_bios *bios)
 {
+       struct nvkm_subdev *subdev = &bios->subdev;
+       struct nvkm_device *device = subdev->device;
        struct shadow mthds[] = {
                { shadow_class, 0, &nvbios_of },
                { shadow_class, 0, &nvbios_ramin },
        int optlen;
 
        /* handle user-specified bios source */
-       optarg = nvkm_stropt(nv_device(bios)->cfgopt, "NvBios", &optlen);
+       optarg = nvkm_stropt(device->cfgopt, "NvBios", &optlen);
        source = optarg ? kstrndup(optarg, optlen, GFP_KERNEL) : NULL;
        if (source) {
                /* try to match one of the built-in methods */
                }
 
                if (!best->score) {
-                       nv_error(bios, "%s invalid\n", source);
+                       nvkm_error(subdev, "%s invalid\n", source);
                        kfree(source);
                        source = NULL;
                }
        }
 
        if (!best->score) {
-               nv_fatal(bios, "unable to locate usable image\n");
+               nvkm_error(subdev, "unable to locate usable image\n");
                return -EINVAL;
        }
 
-       nv_info(bios, "using image from %s\n", best->func ?
-               best->func->name : source);
+       nvkm_debug(subdev, "using image from %s\n", best->func ?
+                  best->func->name : source);
        bios->data = best->data;
        bios->size = best->size;
        kfree(source);
 
 static void *
 pramin_init(struct nvkm_bios *bios, const char *name)
 {
-       struct nvkm_device *device = bios->subdev.device;
+       struct nvkm_subdev *subdev = &bios->subdev;
+       struct nvkm_device *device = subdev->device;
        struct priv *priv = NULL;
        u64 addr = 0;
 
        if (device->card_type >= NV_C0)
                addr = nvkm_rd32(device, 0x022500);
        if (addr & 0x00000001) {
-               nv_debug(bios, "... display disabled\n");
+               nvkm_debug(subdev, "... display disabled\n");
                return ERR_PTR(-ENODEV);
        }
 
         */
        addr = nvkm_rd32(device, 0x619f04);
        if (!(addr & 0x00000008)) {
-               nv_debug(bios, "... not enabled\n");
+               nvkm_debug(subdev, "... not enabled\n");
                return ERR_PTR(-ENODEV);
        }
        if ( (addr & 0x00000003) != 1) {
-               nv_debug(bios, "... not in vram\n");
+               nvkm_debug(subdev, "... not in vram\n");
                return ERR_PTR(-ENODEV);
        }
 
 
        /* modify bar0 PRAMIN window to cover the bios image */
        if (!(priv = kmalloc(sizeof(*priv), GFP_KERNEL))) {
-               nv_error(bios, "... out of memory\n");
+               nvkm_error(subdev, "... out of memory\n");
                return ERR_PTR(-ENOMEM);
        }
 
 
                else if (bit_P.version == 2)
                        therm = nv_ro16(bios, bit_P.offset + 16);
                else
-                       nv_error(bios,
-                               "unknown offset for thermal in BIT P %d\n",
-                               bit_P.version);
+                       nvkm_error(&bios->subdev,
+                                  "unknown offset for thermal in BIT P %d\n",
+                                  bit_P.version);
        }
 
        /* exit now if we haven't found the thermal table */