1 files changed, 40 insertions, 38 deletions

diff --git a/drivers/gpu/drm/ttm/ttm_tt.c b/drivers/gpu/drm/ttm/ttm_tt.c
index 7bcb89f39ce8..d5fd5b8faeb3 100644
--- a/drivers/gpu/drm/ttm/ttm_tt.c
+++ b/drivers/gpu/drm/ttm/ttm_tt.c
@@ -28,13 +28,14 @@
  * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
  */
 
-#include <linux/vmalloc.h>
 #include <linux/sched.h>
 #include <linux/highmem.h>
 #include <linux/pagemap.h>
 #include <linux/file.h>
 #include <linux/swap.h>
+#include <linux/slab.h>
 #include "drm_cache.h"
+#include "drm_mem_util.h"
 #include "ttm/ttm_module.h"
 #include "ttm/ttm_bo_driver.h"
 #include "ttm/ttm_placement.h"
@@ -43,32 +44,15 @@ static int ttm_tt_swapin(struct ttm_tt *ttm);
 
 /**
  * Allocates storage for pointers to the pages that back the ttm.
- *
- * Uses kmalloc if possible. Otherwise falls back to vmalloc.
  */
 static void ttm_tt_alloc_page_directory(struct ttm_tt *ttm)
 {
-        unsigned long size = ttm->num_pages * sizeof(*ttm->pages);
-        ttm->pages = NULL;
-
-        if (size <= PAGE_SIZE)
-                ttm->pages = kzalloc(size, GFP_KERNEL);
-
-        if (!ttm->pages) {
-                ttm->pages = vmalloc_user(size);
-                if (ttm->pages)
-                        ttm->page_flags |= TTM_PAGE_FLAG_VMALLOC;
-        }
+        ttm->pages = drm_calloc_large(ttm->num_pages, sizeof(*ttm->pages));
 }
 
 static void ttm_tt_free_page_directory(struct ttm_tt *ttm)
 {
-        if (ttm->page_flags & TTM_PAGE_FLAG_VMALLOC) {
-                vfree(ttm->pages);
-                ttm->page_flags &= ~TTM_PAGE_FLAG_VMALLOC;
-        } else {
-                kfree(ttm->pages);
-        }
+        drm_free_large(ttm->pages);
         ttm->pages = NULL;
 }
 
@@ -192,26 +176,38 @@ int ttm_tt_populate(struct ttm_tt *ttm)
         ttm->state = tt_unbound;
         return 0;
 }
+EXPORT_SYMBOL(ttm_tt_populate);
 
 #ifdef CONFIG_X86
 static inline int ttm_tt_set_page_caching(struct page *p,
-                                          enum ttm_caching_state c_state)
+                                          enum ttm_caching_state c_old,
+                                          enum ttm_caching_state c_new)
 {
+        int ret = 0;
+
         if (PageHighMem(p))
                 return 0;
 
-        switch (c_state) {
-        case tt_cached:
-                return set_pages_wb(p, 1);
-        case tt_wc:
-            return set_memory_wc((unsigned long) page_address(p), 1);
-        default:
-                return set_pages_uc(p, 1);
+        if (c_old != tt_cached) {
+                /* p isn't in the default caching state, set it to
+                 * writeback first to free its current memtype. */
+
+                ret = set_pages_wb(p, 1);
+                if (ret)
+                        return ret;
         }
+
+        if (c_new == tt_wc)
+                ret = set_memory_wc((unsigned long) page_address(p), 1);
+        else if (c_new == tt_uncached)
+                ret = set_pages_uc(p, 1);
+
+        return ret;
 }
 #else /* CONFIG_X86 */
 static inline int ttm_tt_set_page_caching(struct page *p,
-                                          enum ttm_caching_state c_state)
+                                          enum ttm_caching_state c_old,
+                                          enum ttm_caching_state c_new)
 {
         return 0;
 }
@@ -244,7 +240,9 @@ static int ttm_tt_set_caching(struct ttm_tt *ttm,
         for (i = 0; i < ttm->num_pages; ++i) {
                 cur_page = ttm->pages[i];
                 if (likely(cur_page != NULL)) {
-                        ret = ttm_tt_set_page_caching(cur_page, c_state);
+                        ret = ttm_tt_set_page_caching(cur_page,
+                                                      ttm->caching_state,
+                                                      c_state);
                         if (unlikely(ret != 0))
                                 goto out_err;
                 }
@@ -258,7 +256,7 @@ out_err:
         for (j = 0; j < i; ++j) {
                 cur_page = ttm->pages[j];
                 if (likely(cur_page != NULL)) {
-                        (void)ttm_tt_set_page_caching(cur_page,
+                        (void)ttm_tt_set_page_caching(cur_page, c_state,
                                                       ttm->caching_state);
                 }
         }
@@ -466,7 +464,7 @@ static int ttm_tt_swapin(struct ttm_tt *ttm)
         void *from_virtual;
         void *to_virtual;
         int i;
-        int ret;
+        int ret = -ENOMEM;
 
         if (ttm->page_flags & TTM_PAGE_FLAG_USER) {
                 ret = ttm_tt_set_user(ttm, ttm->tsk, ttm->start,
@@ -485,8 +483,10 @@ static int ttm_tt_swapin(struct ttm_tt *ttm)
 
         for (i = 0; i < ttm->num_pages; ++i) {
                 from_page = read_mapping_page(swap_space, i, NULL);
-                if (IS_ERR(from_page))
+                if (IS_ERR(from_page)) {
+                        ret = PTR_ERR(from_page);
                         goto out_err;
+                }
                 to_page = __ttm_tt_get_page(ttm, i);
                 if (unlikely(to_page == NULL))
                         goto out_err;
@@ -509,7 +509,7 @@ static int ttm_tt_swapin(struct ttm_tt *ttm)
         return 0;
 out_err:
         ttm_tt_free_alloced_pages(ttm);
-        return -ENOMEM;
+        return ret;
 }
 
 int ttm_tt_swapout(struct ttm_tt *ttm, struct file *persistant_swap_storage)
@@ -521,6 +521,7 @@ int ttm_tt_swapout(struct ttm_tt *ttm, struct file *persistant_swap_storage)
         void *from_virtual;
         void *to_virtual;
         int i;
+        int ret = -ENOMEM;
 
         BUG_ON(ttm->state != tt_unbound && ttm->state != tt_unpopulated);
         BUG_ON(ttm->caching_state != tt_cached);
@@ -543,7 +544,7 @@ int ttm_tt_swapout(struct ttm_tt *ttm, struct file *persistant_swap_storage)
                                                 0);
                 if (unlikely(IS_ERR(swap_storage))) {
                         printk(KERN_ERR "Failed allocating swap storage.\n");
-                        return -ENOMEM;
+                        return PTR_ERR(swap_storage);
                 }
         } else
                 swap_storage = persistant_swap_storage;
@@ -555,9 +556,10 @@ int ttm_tt_swapout(struct ttm_tt *ttm, struct file *persistant_swap_storage)
                 if (unlikely(from_page == NULL))
                         continue;
                 to_page = read_mapping_page(swap_space, i, NULL);
-                if (unlikely(to_page == NULL))
+                if (unlikely(IS_ERR(to_page))) {
+                        ret = PTR_ERR(to_page);
                         goto out_err;
-
+                }
                 preempt_disable();
                 from_virtual = kmap_atomic(from_page, KM_USER0);
                 to_virtual = kmap_atomic(to_page, KM_USER1);
@@ -581,5 +583,5 @@ out_err:
         if (!persistant_swap_storage)
                 fput(swap_storage);
 
-        return -ENOMEM;
+        return ret;
 }