gpuobj->size = size;
 
        if (heap) {
-               ret = nouveau_mm_head(heap, 1, size, size,
+               ret = nouveau_mm_head(heap, 0, 1, size, size,
                                      max(align, (u32)1), &gpuobj->node);
                if (ret)
                        return ret;
 
 
        b->offset = a->offset;
        b->length = size;
+       b->heap   = a->heap;
        b->type   = a->type;
        a->offset += size;
        a->length -= size;
 }
 
 int
-nouveau_mm_head(struct nouveau_mm *mm, u8 type, u32 size_max, u32 size_min,
-               u32 align, struct nouveau_mm_node **pnode)
+nouveau_mm_head(struct nouveau_mm *mm, u8 heap, u8 type, u32 size_max,
+               u32 size_min, u32 align, struct nouveau_mm_node **pnode)
 {
        struct nouveau_mm_node *prev, *this, *next;
        u32 mask = align - 1;
        BUG_ON(type == NVKM_MM_TYPE_NONE || type == NVKM_MM_TYPE_HOLE);
 
        list_for_each_entry(this, &mm->free, fl_entry) {
+               if (unlikely(heap != NVKM_MM_HEAP_ANY)) {
+                       if (this->heap != heap)
+                               continue;
+               }
                e = this->offset + this->length;
                s = this->offset;
 
        a->length -= size;
        b->offset  = a->offset + a->length;
        b->length  = size;
+       b->heap    = a->heap;
        b->type    = a->type;
 
        list_add(&b->nl_entry, &a->nl_entry);
 }
 
 int
-nouveau_mm_tail(struct nouveau_mm *mm, u8 type, u32 size_max, u32 size_min,
-               u32 align, struct nouveau_mm_node **pnode)
+nouveau_mm_tail(struct nouveau_mm *mm, u8 heap, u8 type, u32 size_max,
+               u32 size_min, u32 align, struct nouveau_mm_node **pnode)
 {
        struct nouveau_mm_node *prev, *this, *next;
        u32 mask = align - 1;
                u32 e = this->offset + this->length;
                u32 s = this->offset;
                u32 c = 0, a;
+               if (unlikely(heap != NVKM_MM_HEAP_ANY)) {
+                       if (this->heap != heap)
+                               continue;
+               }
 
                prev = node(this, prev);
                if (prev && prev->type != type)
 
        list_add_tail(&node->nl_entry, &mm->nodes);
        list_add_tail(&node->fl_entry, &mm->free);
-       mm->heap_nodes++;
+       node->heap = ++mm->heap_nodes;
        return 0;
 }
 
 
        struct list_head fl_entry;
        struct list_head rl_entry;
 
+#define NVKM_MM_HEAP_ANY 0x00
+       u8  heap;
 #define NVKM_MM_TYPE_NONE 0x00
 #define NVKM_MM_TYPE_HOLE 0xff
        u8  type;
 
 int  nouveau_mm_init(struct nouveau_mm *, u32 offset, u32 length, u32 block);
 int  nouveau_mm_fini(struct nouveau_mm *);
-int  nouveau_mm_head(struct nouveau_mm *, u8 type, u32 size_max, u32 size_min,
-                    u32 align, struct nouveau_mm_node **);
-int  nouveau_mm_tail(struct nouveau_mm *, u8 type, u32 size_max, u32 size_min,
-                    u32 align, struct nouveau_mm_node **);
+int  nouveau_mm_head(struct nouveau_mm *, u8 heap, u8 type, u32 size_max,
+                    u32 size_min, u32 align, struct nouveau_mm_node **);
+int  nouveau_mm_tail(struct nouveau_mm *, u8 heap, u8 type, u32 size_max,
+                    u32 size_min, u32 align, struct nouveau_mm_node **);
 void nouveau_mm_free(struct nouveau_mm *, struct nouveau_mm_node **);
 
 #endif
 
 {
        u32 tiles = DIV_ROUND_UP(size, 0x40);
        u32 tags  = round_up(tiles / pfb->ram->parts, 0x40);
-       if (!nouveau_mm_head(&pfb->tags, 1, tags, tags, 1, &tile->tag)) {
+       if (!nouveau_mm_head(&pfb->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;
 
 {
        u32 tiles = DIV_ROUND_UP(size, 0x40);
        u32 tags  = round_up(tiles / pfb->ram->parts, 0x40);
-       if (!nouveau_mm_head(&pfb->tags, 1, tags, tags, 1, &tile->tag)) {
+       if (!nouveau_mm_head(&pfb->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 / pfb->ram->parts, 0x40);
-       if (!nouveau_mm_head(&pfb->tags, 1, tags, tags, 1, &tile->tag)) {
+       if (!nouveau_mm_head(&pfb->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 / pfb->ram->parts, 0x40);
-       if (!nouveau_mm_head(&pfb->tags, 1, tags, tags, 1, &tile->tag)) {
+       if (!nouveau_mm_head(&pfb->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 / pfb->ram->parts, 0x40);
-       if (!nouveau_mm_head(&pfb->tags, 1, tags, tags, 1, &tile->tag)) {
+       if (!nouveau_mm_head(&pfb->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 / pfb->ram->parts, 0x100);
        if ( (flags & 2) &&
-           !nouveau_mm_head(&pfb->tags, 1, tags, tags, 1, &tile->tag)) {
+           !nouveau_mm_head(&pfb->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 (align == 16) {
                        int n = (max >> 4) * comp;
 
-                       ret = nouveau_mm_head(tags, 1, n, n, 1, &mem->tag);
+                       ret = nouveau_mm_head(tags, 0, 1, n, n, 1, &mem->tag);
                        if (ret)
                                mem->tag = NULL;
                }
        type = nv50_fb_memtype[type];
        do {
                if (back)
-                       ret = nouveau_mm_tail(heap, type, max, min, align, &r);
+                       ret = nouveau_mm_tail(heap, 0, type, max, min, align, &r);
                else
-                       ret = nouveau_mm_head(heap, type, max, min, align, &r);
+                       ret = nouveau_mm_head(heap, 0, type, max, min, align, &r);
                if (ret) {
                        mutex_unlock(&pfb->base.mutex);
                        pfb->ram->put(pfb, &mem);
 
 
        do {
                if (back)
-                       ret = nouveau_mm_tail(mm, 1, size, ncmin, align, &r);
+                       ret = nouveau_mm_tail(mm, 0, 1, size, ncmin, align, &r);
                else
-                       ret = nouveau_mm_head(mm, 1, size, ncmin, align, &r);
+                       ret = nouveau_mm_head(mm, 0, 1, size, ncmin, align, &r);
                if (ret) {
                        mutex_unlock(&pfb->base.mutex);
                        pfb->ram->put(pfb, &mem);
 
        if (ret)
                return ret;
 
-       ret = nouveau_mm_head(&priv->heap, 1, args->size, args->size,
+       ret = nouveau_mm_head(&priv->heap, 0, 1, args->size, args->size,
                              args->align, &node->mem);
        if (ret)
                return ret;
 
        struct nvkm_ltc_priv *priv = (void *)ltc;
        int ret;
 
-       ret = nouveau_mm_head(&priv->tags, 1, n, n, 1, pnode);
+       ret = nouveau_mm_head(&priv->tags, 0, 1, n, n, 1, pnode);
        if (ret)
                *pnode = NULL;
 
 
        tag_size += tag_align;
        tag_size  = (tag_size + 0xfff) >> 12; /* round up */
 
-       ret = nouveau_mm_tail(&pfb->vram, 1, tag_size, tag_size, 1,
+       ret = nouveau_mm_tail(&pfb->vram, 0, 1, tag_size, tag_size, 1,
                              &priv->tag_ram);
        if (ret) {
                priv->num_tags = 0;
 
        int ret;
 
        mutex_lock(&nv_subdev(vmm)->mutex);
-       ret = nouveau_mm_head(&vm->mm, page_shift, msize, msize, align,
+       ret = nouveau_mm_head(&vm->mm, 0, page_shift, msize, msize, align,
                             &vma->node);
        if (unlikely(ret != 0)) {
                mutex_unlock(&nv_subdev(vmm)->mutex);
 
        list_add(&ntfy->head, &chan->notifiers);
        ntfy->handle = info->handle;
 
-       ret = nouveau_mm_head(&chan->heap, 1, info->size, info->size, 1,
+       ret = nouveau_mm_head(&chan->heap, 0, 1, info->size, info->size, 1,
                              &ntfy->node);
        if (ret)
                goto done;