{
        struct vmw_user_buffer_object *vmw_user_bo;
        struct ttm_base_object *base = *p_base;
-       struct ttm_buffer_object *bo;
 
        *p_base = NULL;
 
 
        vmw_user_bo = container_of(base, struct vmw_user_buffer_object,
                                   prime.base);
-       bo = &vmw_user_bo->vbo.base;
-       ttm_bo_unref(&bo);
+       ttm_bo_put(&vmw_user_bo->vbo.base);
 }
 
 
                      struct ttm_base_object **p_base)
 {
        struct vmw_user_buffer_object *user_bo;
-       struct ttm_buffer_object *tmp;
        int ret;
 
        user_bo = kzalloc(sizeof(*user_bo), GFP_KERNEL);
                return ret;
 
        ttm_bo_get(&user_bo->vbo.base);
-       tmp = &user_bo->vbo.base;
        ret = ttm_prime_object_init(tfile,
                                    size,
                                    &user_bo->prime,
                                    &vmw_user_bo_release,
                                    &vmw_user_bo_ref_obj_release);
        if (unlikely(ret != 0)) {
-               ttm_bo_unref(&tmp);
+               ttm_bo_put(&user_bo->vbo.base);
                goto out_no_base_object;
        }
 
 
 
        if (info->done)
                return true;
- 
+
        memset(info->node, 0, sizeof(*info->node));
        spin_lock(&man->lock);
        ret = drm_mm_insert_node(&man->mm, info->node, info->page_size);
        return 0;
 
 out_no_map:
-       if (man->using_mob)
-               ttm_bo_unref(&man->cmd_space);
+       if (man->using_mob) {
+               ttm_bo_put(man->cmd_space);
+               man->cmd_space = NULL;
+       }
 
        return ret;
 }
        (void) vmw_cmdbuf_idle(man, false, 10*HZ);
        if (man->using_mob) {
                (void) ttm_bo_kunmap(&man->map_obj);
-               ttm_bo_unref(&man->cmd_space);
+               ttm_bo_put(man->cmd_space);
+               man->cmd_space = NULL;
        } else {
                dma_free_coherent(&man->dev_priv->dev->pdev->dev,
                                  man->size, man->map, man->handle);
 
 
        *buf = NULL;
        if (tmp_buf != NULL) {
-               struct ttm_buffer_object *bo = &tmp_buf->base;
-
-               ttm_bo_unref(&bo);
+               ttm_bo_put(&tmp_buf->base);
        }
 }
 
 
                                                 &batch->otables[i]);
        }
 
-       ttm_bo_unref(&batch->otable_bo);
+       ttm_bo_put(batch->otable_bo);
+       batch->otable_bo = NULL;
 out_no_bo:
        return ret;
 }
        vmw_bo_fence_single(bo, NULL);
        ttm_bo_unreserve(bo);
 
-       ttm_bo_unref(&batch->otable_bo);
+       ttm_bo_put(batch->otable_bo);
+       batch->otable_bo = NULL;
 }
 
 /*
 
 out_unreserve:
        ttm_bo_unreserve(mob->pt_bo);
-       ttm_bo_unref(&mob->pt_bo);
+       ttm_bo_put(mob->pt_bo);
+       mob->pt_bo = NULL;
 
        return ret;
 }
  */
 void vmw_mob_destroy(struct vmw_mob *mob)
 {
-       if (mob->pt_bo)
-               ttm_bo_unref(&mob->pt_bo);
+       if (mob->pt_bo) {
+               ttm_bo_put(mob->pt_bo);
+               mob->pt_bo = NULL;
+       }
        kfree(mob);
 }
 
 
 out_no_cmd_space:
        vmw_fifo_resource_dec(dev_priv);
-       if (pt_set_up)
-               ttm_bo_unref(&mob->pt_bo);
+       if (pt_set_up) {
+               ttm_bo_put(mob->pt_bo);
+               mob->pt_bo = NULL;
+       }
 
        return -ENOMEM;
 }
 
 out_no_validate:
        ttm_eu_backoff_reservation(ticket, &val_list);
 out_no_reserve:
-       ttm_bo_unref(&val_buf->bo);
+       ttm_bo_put(val_buf->bo);
+       val_buf->bo = NULL;
        if (backup_dirty)
                vmw_bo_unreference(&res->backup);
 
        INIT_LIST_HEAD(&val_list);
        list_add_tail(&val_buf->head, &val_list);
        ttm_eu_backoff_reservation(ticket, &val_list);
-       ttm_bo_unref(&val_buf->bo);
+       ttm_bo_put(val_buf->bo);
+       val_buf->bo = NULL;
 }
 
 /**
 
        struct vmw_validation_bo_node *entry;
        struct vmw_validation_res_node *val;
 
-       list_for_each_entry(entry, &ctx->bo_list, base.head)
-               ttm_bo_unref(&entry->base.bo);
+       list_for_each_entry(entry, &ctx->bo_list, base.head) {
+               ttm_bo_put(entry->base.bo);
+               entry->base.bo = NULL;
+       }
 
        list_splice_init(&ctx->resource_ctx_list, &ctx->resource_list);
        list_for_each_entry(val, &ctx->resource_list, head)