if (r)
                return r;
 
-       r = radeon_vm_manager_start(rdev);
-       if (r)
+       r = radeon_vm_manager_init(rdev);
+       if (r) {
+               dev_err(rdev->dev, "vm manager initialization failed (%d).\n", r);
                return r;
+       }
 
        r = r600_audio_init(rdev);
        if (r)
 int cayman_suspend(struct radeon_device *rdev)
 {
        r600_audio_fini(rdev);
-       radeon_vm_manager_suspend(rdev);
        cayman_cp_enable(rdev, false);
        rdev->ring[RADEON_RING_TYPE_GFX_INDEX].ready = false;
        evergreen_irq_suspend(rdev);
                return r;
 
        rdev->accel_working = true;
-       r = radeon_vm_manager_init(rdev);
-       if (r) {
-               dev_err(rdev->dev, "vm manager initialization failed (%d).\n", r);
-       }
-
        r = cayman_startup(rdev);
        if (r) {
                dev_err(rdev->dev, "disabling GPU acceleration\n");
 
  *
  * TODO bind a default page at vm initialization for default address
  */
+
 int radeon_vm_manager_init(struct radeon_device *rdev)
 {
+       struct radeon_vm *vm;
+       struct radeon_bo_va *bo_va;
        int r;
 
-       rdev->vm_manager.enabled = false;
+       if (!rdev->vm_manager.enabled) {
+               /* mark first vm as always in use, it's the system one */
+               r = radeon_sa_bo_manager_init(rdev, &rdev->vm_manager.sa_manager,
+                                             rdev->vm_manager.max_pfn * 8,
+                                             RADEON_GEM_DOMAIN_VRAM);
+               if (r) {
+                       dev_err(rdev->dev, "failed to allocate vm bo (%dKB)\n",
+                               (rdev->vm_manager.max_pfn * 8) >> 10);
+                       return r;
+               }
 
-       /* mark first vm as always in use, it's the system one */
-       r = radeon_sa_bo_manager_init(rdev, &rdev->vm_manager.sa_manager,
-                                     rdev->vm_manager.max_pfn * 8,
-                                     RADEON_GEM_DOMAIN_VRAM);
-       if (r) {
-               dev_err(rdev->dev, "failed to allocate vm bo (%dKB)\n",
-                       (rdev->vm_manager.max_pfn * 8) >> 10);
-               return r;
+               r = rdev->vm_manager.funcs->init(rdev);
+               if (r)
+                       return r;
+       
+               rdev->vm_manager.enabled = true;
+
+               r = radeon_sa_bo_manager_start(rdev, &rdev->vm_manager.sa_manager);
+               if (r)
+                       return r;
        }
 
-       r = rdev->vm_manager.funcs->init(rdev);
-       if (r == 0)
-               rdev->vm_manager.enabled = true;
+       /* restore page table */
+       list_for_each_entry(vm, &rdev->vm_manager.lru_vm, list) {
+               if (vm->id == -1)
+                       continue;
 
-       return r;
+               list_for_each_entry(bo_va, &vm->va, vm_list) {
+                       struct ttm_mem_reg *mem = NULL;
+                       if (bo_va->valid)
+                               mem = &bo_va->bo->tbo.mem;
+
+                       bo_va->valid = false;
+                       r = radeon_vm_bo_update_pte(rdev, vm, bo_va->bo, mem);
+                       if (r) {
+                               DRM_ERROR("Failed to update pte for vm %d!\n", vm->id);
+                       }
+               }
+
+               r = rdev->vm_manager.funcs->bind(rdev, vm, vm->id);
+               if (r) {
+                       DRM_ERROR("Failed to bind vm %d!\n", vm->id);
+               }
+       }
+       return 0;
 }
 
 /* global mutex must be lock */
 }
 
 void radeon_vm_manager_fini(struct radeon_device *rdev)
-{
-       if (rdev->vm_manager.sa_manager.bo == NULL)
-               return;
-       radeon_vm_manager_suspend(rdev);
-       rdev->vm_manager.funcs->fini(rdev);
-       radeon_sa_bo_manager_fini(rdev, &rdev->vm_manager.sa_manager);
-       rdev->vm_manager.enabled = false;
-}
-
-int radeon_vm_manager_start(struct radeon_device *rdev)
-{
-       if (rdev->vm_manager.sa_manager.bo == NULL) {
-               return -EINVAL;
-       }
-       return radeon_sa_bo_manager_start(rdev, &rdev->vm_manager.sa_manager);
-}
-
-int radeon_vm_manager_suspend(struct radeon_device *rdev)
 {
        struct radeon_vm *vm, *tmp;
 
+       if (!rdev->vm_manager.enabled)
+               return;
+
        mutex_lock(&rdev->vm_manager.lock);
        /* unbind all active vm */
        list_for_each_entry_safe(vm, tmp, &rdev->vm_manager.lru_vm, list) {
        }
        rdev->vm_manager.funcs->fini(rdev);
        mutex_unlock(&rdev->vm_manager.lock);
-       return radeon_sa_bo_manager_suspend(rdev, &rdev->vm_manager.sa_manager);
+
+       radeon_sa_bo_manager_suspend(rdev, &rdev->vm_manager.sa_manager);
+       radeon_sa_bo_manager_fini(rdev, &rdev->vm_manager.sa_manager);
+       rdev->vm_manager.enabled = false;
 }
 
 /* global mutex must be locked */
 
                return r;
        }
 
-       r = radeon_vm_manager_start(rdev);
-       if (r)
+       r = radeon_vm_manager_init(rdev);
+       if (r) {
+               dev_err(rdev->dev, "vm manager initialization failed (%d).\n", r);
                return r;
+       }
 
        return 0;
 }
 
 int si_suspend(struct radeon_device *rdev)
 {
-       radeon_vm_manager_suspend(rdev);
        si_cp_enable(rdev, false);
        rdev->ring[RADEON_RING_TYPE_GFX_INDEX].ready = false;
        rdev->ring[CAYMAN_RING_TYPE_CP1_INDEX].ready = false;
                return r;
 
        rdev->accel_working = true;
-       r = radeon_vm_manager_init(rdev);
-       if (r) {
-               dev_err(rdev->dev, "vm manager initialization failed (%d).\n", r);
-       }
-
        r = si_startup(rdev);
        if (r) {
                dev_err(rdev->dev, "disabling GPU acceleration\n");