struct nvkm_subdev subdev;
 
        struct nvkm_ram *ram;
+       struct nvkm_mm tags;
 
        struct {
                struct nvkm_fb_tile region[16];
 #define NVKM_RAM_MM_NOMAP  (NVKM_MM_HEAP_ANY + 2)
 #define NVKM_RAM_MM_MIXED  (NVKM_MM_HEAP_ANY + 3)
        struct nvkm_mm vram;
-       struct nvkm_mm tags;
        u64 stolen;
 
        int ranks;
 
        for (i = 0; i < fb->tile.regions; i++)
                fb->func->tile.fini(fb, i, &fb->tile.region[i]);
 
+       nvkm_mm_fini(&fb->tags);
        nvkm_ram_del(&fb->ram);
 
        if (fb->func->dtor)
 
 {
        u32 tiles = DIV_ROUND_UP(size, 0x40);
        u32 tags  = round_up(tiles / fb->ram->parts, 0x40);
-       if (!nvkm_mm_head(&fb->ram->tags, 0, 1, tags, tags, 1, &tile->tag)) {
+       if (!nvkm_mm_head(&fb->tags, 0, 1, tags, tags, 1, &tile->tag)) {
                if (!(flags & 2)) tile->zcomp = 0x00000000; /* Z16 */
                else              tile->zcomp = 0x04000000; /* Z24S8 */
                tile->zcomp |= tile->tag->offset;
        tile->limit = 0;
        tile->pitch = 0;
        tile->zcomp = 0;
-       nvkm_mm_free(&fb->ram->tags, &tile->tag);
+       nvkm_mm_free(&fb->tags, &tile->tag);
 }
 
 void
 
 {
        u32 tiles = DIV_ROUND_UP(size, 0x40);
        u32 tags  = round_up(tiles / fb->ram->parts, 0x40);
-       if (!nvkm_mm_head(&fb->ram->tags, 0, 1, tags, tags, 1, &tile->tag)) {
+       if (!nvkm_mm_head(&fb->tags, 0, 1, tags, tags, 1, &tile->tag)) {
                if (!(flags & 2)) tile->zcomp = 0x00100000; /* Z16 */
                else              tile->zcomp = 0x00200000; /* Z24S8 */
                tile->zcomp |= tile->tag->offset;
 
 {
        u32 tiles = DIV_ROUND_UP(size, 0x40);
        u32 tags  = round_up(tiles / fb->ram->parts, 0x40);
-       if (!nvkm_mm_head(&fb->ram->tags, 0, 1, tags, tags, 1, &tile->tag)) {
+       if (!nvkm_mm_head(&fb->tags, 0, 1, tags, tags, 1, &tile->tag)) {
                if (flags & 2) tile->zcomp |= 0x01000000; /* Z16 */
                else           tile->zcomp |= 0x02000000; /* Z24S8 */
                tile->zcomp |= ((tile->tag->offset           ) >> 6);
 
 {
        u32 tiles = DIV_ROUND_UP(size, 0x40);
        u32 tags  = round_up(tiles / fb->ram->parts, 0x40);
-       if (!nvkm_mm_head(&fb->ram->tags, 0, 1, tags, tags, 1, &tile->tag)) {
+       if (!nvkm_mm_head(&fb->tags, 0, 1, tags, tags, 1, &tile->tag)) {
                if (flags & 2) tile->zcomp |= 0x04000000; /* Z16 */
                else           tile->zcomp |= 0x08000000; /* Z24S8 */
                tile->zcomp |= ((tile->tag->offset           ) >> 6);
 
 {
        u32 tiles = DIV_ROUND_UP(size, 0x40);
        u32 tags  = round_up(tiles / fb->ram->parts, 0x40);
-       if (!nvkm_mm_head(&fb->ram->tags, 0, 1, tags, tags, 1, &tile->tag)) {
+       if (!nvkm_mm_head(&fb->tags, 0, 1, tags, tags, 1, &tile->tag)) {
                if (flags & 2) tile->zcomp |= 0x10000000; /* Z16 */
                else           tile->zcomp |= 0x20000000; /* Z24S8 */
                tile->zcomp |= ((tile->tag->offset           ) >> 6);
 
        u32 tiles = DIV_ROUND_UP(size, 0x80);
        u32 tags  = round_up(tiles / fb->ram->parts, 0x100);
        if ( (flags & 2) &&
-           !nvkm_mm_head(&fb->ram->tags, 0, 1, tags, tags, 1, &tile->tag)) {
+           !nvkm_mm_head(&fb->tags, 0, 1, tags, tags, 1, &tile->tag)) {
                tile->zcomp  = 0x28000000; /* Z24S8_SPLIT_GRAD */
                tile->zcomp |= ((tile->tag->offset           ) >> 8);
                tile->zcomp |= ((tile->tag->offset + tags - 1) >> 8) << 13;
 
        if (ram && !WARN_ON(!ram->func)) {
                if (ram->func->dtor)
                        *pram = ram->func->dtor(ram);
-               nvkm_mm_fini(&ram->tags);
                nvkm_mm_fini(&ram->vram);
                kfree(*pram);
                *pram = NULL;
                        return ret;
        }
 
-       if (!nvkm_mm_initialised(&ram->tags)) {
-               ret = nvkm_mm_init(&ram->tags, 0, 0, tags ? ++tags : 0, 1);
+       if (!nvkm_mm_initialised(&fb->tags)) {
+               ret = nvkm_mm_init(&fb->tags, 0, 0, tags ? ++tags : 0, 1);
                if (ret)
                        return ret;
 
 
                next = node->next;
                nvkm_mm_free(&ram->vram, &node);
        }
-       nvkm_mm_free(&ram->tags, &mem->tag);
+       nvkm_mm_free(&ram->fb->tags, &mem->tag);
 }
 
 void
             u32 memtype, struct nvkm_mem **pmem)
 {
        struct nvkm_mm *heap = &ram->vram;
-       struct nvkm_mm *tags = &ram->tags;
+       struct nvkm_mm *tags = &ram->fb->tags;
        struct nvkm_mm_node **node, *r;
        struct nvkm_mem *mem;
        int comp = (memtype & 0x300) >> 8;