drm/ttm: Reduce differences with Linux 3.9
authorFrançois Tigeot <ftigeot@wolfpond.org>
Sun, 23 Feb 2014 07:13:00 +0000 (08:13 +0100)
committerFrançois Tigeot <ftigeot@wolfpond.org>
Sun, 23 Feb 2014 07:15:04 +0000 (08:15 +0100)
The FreeBSD port of the ttm code was based on some Linux commit which happened
between the 3.8 and 3.9 releases.

For all intents and purposes, it might as well have been based on Linux 3.9.

sys/dev/drm/ttm/ttm_agp_backend.c
sys/dev/drm/ttm/ttm_bo.c
sys/dev/drm/ttm/ttm_bo_manager.c
sys/dev/drm/ttm/ttm_bo_util.c
sys/dev/drm/ttm/ttm_execbuf_util.c
sys/dev/drm/ttm/ttm_lock.c
sys/dev/drm/ttm/ttm_memory.c
sys/dev/drm/ttm/ttm_page_alloc_dma.c [deleted file]
sys/dev/drm/ttm/ttm_tt.c

index c9088c3..f49ac69 100644 (file)
@@ -31,7 +31,8 @@
  * $FreeBSD: head/sys/dev/drm2/ttm/ttm_agp_backend.c 247835 2013-03-05 09:49:34Z kib $
  */
 
-#include <drm/drmP.h>
+#define pr_fmt(fmt) "[TTM] " fmt
+
 #include <drm/ttm/ttm_module.h>
 #include <drm/ttm/ttm_bo_driver.h>
 #include <drm/ttm/ttm_page_alloc.h>
@@ -116,6 +117,8 @@ struct ttm_tt *ttm_agp_tt_create(struct ttm_bo_device *bdev,
        struct ttm_agp_backend *agp_be;
 
        agp_be = kmalloc(sizeof(*agp_be), M_TTM_AGP, M_WAITOK | M_ZERO);
+       if (!agp_be)
+               return NULL;
 
        agp_be->mem = NULL;
        agp_be->bridge = bridge;
@@ -127,6 +130,7 @@ struct ttm_tt *ttm_agp_tt_create(struct ttm_bo_device *bdev,
 
        return &agp_be->ttm;
 }
+EXPORT_SYMBOL(ttm_agp_tt_create);
 
 int ttm_agp_tt_populate(struct ttm_tt *ttm)
 {
@@ -135,10 +139,12 @@ int ttm_agp_tt_populate(struct ttm_tt *ttm)
 
        return ttm_pool_populate(ttm);
 }
+EXPORT_SYMBOL(ttm_agp_tt_populate);
 
 void ttm_agp_tt_unpopulate(struct ttm_tt *ttm)
 {
        ttm_pool_unpopulate(ttm);
 }
+EXPORT_SYMBOL(ttm_agp_tt_unpopulate);
 
 #endif
index 10ff4be..cc79315 100644 (file)
  * $FreeBSD: head/sys/dev/drm2/ttm/ttm_bo.c 248060 2013-03-08 18:11:02Z dumbbell $
  */
 
-#include <drm/drmP.h>
+#define pr_fmt(fmt) "[TTM] " fmt
+
 #include <drm/ttm/ttm_module.h>
 #include <drm/ttm/ttm_bo_driver.h>
 #include <drm/ttm/ttm_placement.h>
+#include <linux/atomic.h>
+#include <linux/export.h>
 
 #define TTM_ASSERT_LOCKED(param)
 #define TTM_DEBUG(fmt, arg...)
@@ -132,8 +135,8 @@ static void ttm_bo_release_list(struct kref *list_kref)
        ttm_mem_global_free(bdev->glob->mem_glob, acc_size);
 }
 
-static int
-ttm_bo_wait_unreserved_locked(struct ttm_buffer_object *bo, bool interruptible)
+static int ttm_bo_wait_unreserved(struct ttm_buffer_object *bo,
+                                 bool interruptible)
 {
        const char *wmsg;
        int flags, ret;
@@ -224,7 +227,7 @@ int ttm_bo_reserve_nolru(struct ttm_buffer_object *bo,
                if (no_wait)
                        return -EBUSY;
 
-               ret = ttm_bo_wait_unreserved_locked(bo, interruptible);
+               ret = ttm_bo_wait_unreserved(bo, interruptible);
 
                if (unlikely(ret))
                        return ret;
@@ -260,6 +263,7 @@ int ttm_bo_reserve_nolru(struct ttm_buffer_object *bo,
 
        return 0;
 }
+EXPORT_SYMBOL(ttm_bo_reserve);
 
 static void ttm_bo_ref_bug(struct kref *list_kref)
 {
@@ -281,15 +285,14 @@ int ttm_bo_reserve(struct ttm_buffer_object *bo,
        int put_count = 0;
        int ret;
 
-       lockmgr(&bo->glob->lru_lock, LK_EXCLUSIVE);
        ret = ttm_bo_reserve_nolru(bo, interruptible, no_wait, use_sequence,
                                   sequence);
        if (likely(ret == 0)) {
+               lockmgr(&glob->lru_lock, LK_EXCLUSIVE);
                put_count = ttm_bo_del_from_lru(bo);
                lockmgr(&glob->lru_lock, LK_RELEASE);
                ttm_bo_list_ref_sub(bo, put_count, true);
-       } else
-               lockmgr(&bo->glob->lru_lock, LK_RELEASE);
+       }
 
        return ret;
 }
@@ -301,13 +304,9 @@ int ttm_bo_reserve_slowpath_nolru(struct ttm_buffer_object *bo,
        int ret;
 
        while (unlikely(atomic_xchg(&bo->reserved, 1) != 0)) {
-               if (bo->seq_valid && sequence == bo->val_seq) {
-                       DRM_ERROR(
-                           "%s: bo->seq_valid && sequence == bo->val_seq",
-                           __func__);
-               }
+               WARN_ON(bo->seq_valid && sequence == bo->val_seq);
 
-               ret = ttm_bo_wait_unreserved_locked(bo, interruptible);
+               ret = ttm_bo_wait_unreserved(bo, interruptible);
 
                if (unlikely(ret))
                        return ret;
@@ -334,16 +333,16 @@ int ttm_bo_reserve_slowpath(struct ttm_buffer_object *bo,
        struct ttm_bo_global *glob = bo->glob;
        int put_count, ret;
 
-       lockmgr(&glob->lru_lock, LK_EXCLUSIVE);
        ret = ttm_bo_reserve_slowpath_nolru(bo, interruptible, sequence);
        if (likely(!ret)) {
+               lockmgr(&glob->lru_lock, LK_EXCLUSIVE);
                put_count = ttm_bo_del_from_lru(bo);
                lockmgr(&glob->lru_lock, LK_RELEASE);
                ttm_bo_list_ref_sub(bo, put_count, true);
-       } else
-               lockmgr(&glob->lru_lock, LK_RELEASE);
+       }
        return ret;
 }
+EXPORT_SYMBOL(ttm_bo_reserve_slowpath);
 
 void ttm_bo_unreserve_locked(struct ttm_buffer_object *bo)
 {
@@ -360,6 +359,7 @@ void ttm_bo_unreserve(struct ttm_buffer_object *bo)
        ttm_bo_unreserve_locked(bo);
        lockmgr(&glob->lru_lock, LK_RELEASE);
 }
+EXPORT_SYMBOL(ttm_bo_unreserve);
 
 /*
  * Call bo->mutex locked.
@@ -641,6 +641,7 @@ static int ttm_bo_cleanup_refs_and_unlock(struct ttm_buffer_object *bo,
                 */
                lockmgr(&bdev->fence_lock, LK_EXCLUSIVE);
                ret = ttm_bo_wait(bo, false, false, true);
+               WARN_ON(ret);
                lockmgr(&bdev->fence_lock, LK_RELEASE);
                if (ret)
                        return ret;
@@ -712,8 +713,10 @@ static int ttm_bo_delayed_delete(struct ttm_bo_device *bdev, bool remove_all)
 
                ret = ttm_bo_reserve_nolru(entry, false, true, false, 0);
                if (remove_all && ret) {
+                       lockmgr(&glob->lru_lock, LK_RELEASE);
                        ret = ttm_bo_reserve_nolru(entry, false, false,
                                                   false, 0);
+                       lockmgr(&glob->lru_lock, LK_EXCLUSIVE);
                }
 
                if (!ret)
@@ -780,6 +783,7 @@ void ttm_bo_unref(struct ttm_buffer_object **p_bo)
        *p_bo = NULL;
        kref_put(&bo->kref, ttm_bo_release);
 }
+EXPORT_SYMBOL(ttm_bo_unref);
 
 int ttm_bo_lock_delayed_workqueue(struct ttm_bo_device *bdev)
 {
@@ -790,6 +794,7 @@ int ttm_bo_lock_delayed_workqueue(struct ttm_bo_device *bdev)
                taskqueue_drain_timeout(taskqueue_thread[mycpuid], &bdev->wq);
        return (pending);
 }
+EXPORT_SYMBOL(ttm_bo_lock_delayed_workqueue);
 
 void ttm_bo_unlock_delayed_workqueue(struct ttm_bo_device *bdev, int resched)
 {
@@ -798,6 +803,7 @@ void ttm_bo_unlock_delayed_workqueue(struct ttm_bo_device *bdev, int resched)
                    ((hz / 100) < 1) ? 1 : hz / 100);
        }
 }
+EXPORT_SYMBOL(ttm_bo_unlock_delayed_workqueue);
 
 static int ttm_bo_evict(struct ttm_buffer_object *bo, bool interruptible,
                        bool no_wait_gpu)
@@ -818,7 +824,7 @@ static int ttm_bo_evict(struct ttm_buffer_object *bo, bool interruptible,
                goto out;
        }
 
-       KKASSERT(ttm_bo_is_reserved(bo));
+       BUG_ON(!ttm_bo_is_reserved(bo));
 
        evict_mem = bo->mem;
        evict_mem.mm_node = NULL;
@@ -888,7 +894,7 @@ static int ttm_mem_evict_first(struct ttm_bo_device *bdev,
        put_count = ttm_bo_del_from_lru(bo);
        lockmgr(&glob->lru_lock, LK_RELEASE);
 
-       KKASSERT(ret == 0);
+       BUG_ON(ret != 0);
 
        ttm_bo_list_ref_sub(bo, put_count, true);
 
@@ -906,6 +912,7 @@ void ttm_bo_mem_put(struct ttm_buffer_object *bo, struct ttm_mem_reg *mem)
        if (mem->mm_node)
                (*man->func->put_node)(man, mem);
 }
+EXPORT_SYMBOL(ttm_bo_mem_put);
 
 /**
  * Repeatedly evict memory from the LRU for @mem_type until we create enough
@@ -1096,6 +1103,7 @@ int ttm_bo_mem_space(struct ttm_buffer_object *bo,
        ret = (has_erestartsys) ? -ERESTART : -ENOMEM;
        return ret;
 }
+EXPORT_SYMBOL(ttm_bo_mem_space);
 
 static
 int ttm_bo_move_buffer(struct ttm_buffer_object *bo,
@@ -1107,7 +1115,7 @@ int ttm_bo_move_buffer(struct ttm_buffer_object *bo,
        struct ttm_mem_reg mem;
        struct ttm_bo_device *bdev = bo->bdev;
 
-       KKASSERT(ttm_bo_is_reserved(bo));
+       BUG_ON(!ttm_bo_is_reserved(bo));
 
        /*
         * FIXME: It's possible to pipeline buffer moves.
@@ -1166,7 +1174,7 @@ int ttm_bo_validate(struct ttm_buffer_object *bo,
 {
        int ret;
 
-       KKASSERT(ttm_bo_is_reserved(bo));
+       BUG_ON(!ttm_bo_is_reserved(bo));
        /* Check that range is valid */
        if (placement->lpfn || placement->fpfn)
                if (placement->fpfn > placement->lpfn ||
@@ -1199,12 +1207,13 @@ int ttm_bo_validate(struct ttm_buffer_object *bo,
        }
        return 0;
 }
+EXPORT_SYMBOL(ttm_bo_validate);
 
 int ttm_bo_check_placement(struct ttm_buffer_object *bo,
                                struct ttm_placement *placement)
 {
-       KKASSERT(!((placement->fpfn || placement->lpfn) &&
-           (bo->mem.num_pages > (placement->lpfn - placement->fpfn))));
+       BUG_ON((placement->fpfn || placement->lpfn) &&
+              (bo->mem.num_pages > (placement->lpfn - placement->fpfn)));
 
        return 0;
 }
@@ -1231,7 +1240,7 @@ int ttm_bo_init(struct ttm_bo_device *bdev,
                if (destroy)
                        (*destroy)(bo);
                else
-                       drm_free(bo, M_TTM_BO);
+                       kfree(bo, M_TTM_BO);
                return -ENOMEM;
        }
 
@@ -1241,7 +1250,7 @@ int ttm_bo_init(struct ttm_bo_device *bdev,
                if (destroy)
                        (*destroy)(bo);
                else
-                       drm_free(bo, M_TTM_BO);
+                       kfree(bo, M_TTM_BO);
                ttm_mem_global_free(mem_glob, acc_size);
                return -EINVAL;
        }
@@ -1302,6 +1311,7 @@ out_err:
 
        return ret;
 }
+EXPORT_SYMBOL(ttm_bo_init);
 
 size_t ttm_bo_acc_size(struct ttm_bo_device *bdev,
                       unsigned long bo_size,
@@ -1315,6 +1325,7 @@ size_t ttm_bo_acc_size(struct ttm_bo_device *bdev,
        size += ttm_round_pot(sizeof(struct ttm_tt));
        return size;
 }
+EXPORT_SYMBOL(ttm_bo_acc_size);
 
 size_t ttm_bo_dma_acc_size(struct ttm_bo_device *bdev,
                           unsigned long bo_size,
@@ -1329,6 +1340,7 @@ size_t ttm_bo_dma_acc_size(struct ttm_bo_device *bdev,
        size += ttm_round_pot(sizeof(struct ttm_dma_tt));
        return size;
 }
+EXPORT_SYMBOL(ttm_bo_dma_acc_size);
 
 int ttm_bo_create(struct ttm_bo_device *bdev,
                        unsigned long size,
@@ -1344,6 +1356,9 @@ int ttm_bo_create(struct ttm_bo_device *bdev,
        int ret;
 
        bo = kmalloc(sizeof(*bo), M_TTM_BO, M_WAITOK | M_ZERO);
+       if (unlikely(bo == NULL))
+               return -ENOMEM;
+
        acc_size = ttm_bo_acc_size(bdev, size, sizeof(struct ttm_buffer_object));
        ret = ttm_bo_init(bdev, bo, size, type, placement, page_alignment,
                          interruptible, persistent_swap_storage, acc_size,
@@ -1353,6 +1368,7 @@ int ttm_bo_create(struct ttm_bo_device *bdev,
 
        return ret;
 }
+EXPORT_SYMBOL(ttm_bo_create);
 
 static int ttm_bo_force_list_clean(struct ttm_bo_device *bdev,
                                        unsigned mem_type, bool allow_errors)
@@ -1411,6 +1427,7 @@ int ttm_bo_clean_mm(struct ttm_bo_device *bdev, unsigned mem_type)
 
        return ret;
 }
+EXPORT_SYMBOL(ttm_bo_clean_mm);
 
 int ttm_bo_evict_mm(struct ttm_bo_device *bdev, unsigned mem_type)
 {
@@ -1428,6 +1445,7 @@ int ttm_bo_evict_mm(struct ttm_bo_device *bdev, unsigned mem_type)
 
        return ttm_bo_force_list_clean(bdev, mem_type, true);
 }
+EXPORT_SYMBOL(ttm_bo_evict_mm);
 
 int ttm_bo_init_mm(struct ttm_bo_device *bdev, unsigned type,
                        unsigned long p_size)
@@ -1435,9 +1453,9 @@ int ttm_bo_init_mm(struct ttm_bo_device *bdev, unsigned type,
        int ret = -EINVAL;
        struct ttm_mem_type_manager *man;
 
-       KKASSERT(type < TTM_NUM_MEM_TYPES);
+       BUG_ON(type >= TTM_NUM_MEM_TYPES);
        man = &bdev->man[type];
-       KKASSERT(!man->has_type);
+       BUG_ON(man->has_type);
        man->io_reserve_fastpath = true;
        man->use_io_reserve_lru = false;
        lockinit(&man->io_reserve_mutex, "ttmman", 0, LK_CANRECURSE);
@@ -1462,6 +1480,7 @@ int ttm_bo_init_mm(struct ttm_bo_device *bdev, unsigned type,
 
        return 0;
 }
+EXPORT_SYMBOL(ttm_bo_init_mm);
 
 static void ttm_bo_global_kobj_release(struct ttm_bo_global *glob)
 {
@@ -1477,6 +1496,7 @@ void ttm_bo_global_release(struct drm_global_reference *ref)
        if (refcount_release(&glob->kobj_ref))
                ttm_bo_global_kobj_release(glob);
 }
+EXPORT_SYMBOL(ttm_bo_global_release);
 
 int ttm_bo_global_init(struct drm_global_reference *ref)
 {
@@ -1514,9 +1534,11 @@ int ttm_bo_global_init(struct drm_global_reference *ref)
 out_no_shrink:
        vm_page_free(glob->dummy_read_page);
 out_no_drp:
-       drm_free(glob, M_DRM_GLOBAL);
+       kfree(glob, M_DRM_GLOBAL);
        return ret;
 }
+EXPORT_SYMBOL(ttm_bo_global_init);
+
 
 int ttm_bo_device_release(struct ttm_bo_device *bdev)
 {
@@ -1556,13 +1578,14 @@ int ttm_bo_device_release(struct ttm_bo_device *bdev)
                TTM_DEBUG("Swap list was clean\n");
        lockmgr(&glob->lru_lock, LK_RELEASE);
 
-       KKASSERT(drm_mm_clean(&bdev->addr_space_mm));
+       BUG_ON(!drm_mm_clean(&bdev->addr_space_mm));
        lockmgr(&bdev->vm_lock, LK_EXCLUSIVE);
        drm_mm_takedown(&bdev->addr_space_mm);
        lockmgr(&bdev->vm_lock, LK_RELEASE);
 
        return ret;
 }
+EXPORT_SYMBOL(ttm_bo_device_release);
 
 int ttm_bo_device_init(struct ttm_bo_device *bdev,
                       struct ttm_bo_global *glob,
@@ -1608,6 +1631,7 @@ out_no_addr_mm:
 out_no_sys:
        return ret;
 }
+EXPORT_SYMBOL(ttm_bo_device_init);
 
 /*
  * buffer object vm functions.
@@ -1647,6 +1671,9 @@ void ttm_bo_unmap_virtual(struct ttm_buffer_object *bo)
        ttm_mem_io_unlock(man);
 }
 
+
+EXPORT_SYMBOL(ttm_bo_unmap_virtual);
+
 static void ttm_bo_vm_insert_rb(struct ttm_buffer_object *bo)
 {
        struct ttm_bo_device *bdev = bo->bdev;
@@ -1756,6 +1783,7 @@ int ttm_bo_wait(struct ttm_buffer_object *bo,
        }
        return 0;
 }
+EXPORT_SYMBOL(ttm_bo_wait);
 
 int ttm_bo_synccpu_write_grab(struct ttm_buffer_object *bo, bool no_wait)
 {
@@ -1777,11 +1805,13 @@ int ttm_bo_synccpu_write_grab(struct ttm_buffer_object *bo, bool no_wait)
        ttm_bo_unreserve(bo);
        return ret;
 }
+EXPORT_SYMBOL(ttm_bo_synccpu_write_grab);
 
 void ttm_bo_synccpu_write_release(struct ttm_buffer_object *bo)
 {
        atomic_dec(&bo->cpu_writers);
 }
+EXPORT_SYMBOL(ttm_bo_synccpu_write_release);
 
 /**
  * A buffer object shrink method that tries to swap out the first
@@ -1877,3 +1907,4 @@ void ttm_bo_swapout_all(struct ttm_bo_device *bdev)
        while (ttm_bo_swapout(&bdev->glob->shrink) == 0)
                ;
 }
+EXPORT_SYMBOL(ttm_bo_swapout_all);
index 4e527c3..377b2f1 100644 (file)
  * $FreeBSD: head/sys/dev/drm2/ttm/ttm_bo_manager.c 247835 2013-03-05 09:49:34Z kib $
  */
 
-#include <drm/drmP.h>
 #include <drm/ttm/ttm_module.h>
 #include <drm/ttm/ttm_bo_driver.h>
 #include <drm/ttm/ttm_placement.h>
 #include <drm/drm_mm.h>
+#include <linux/export.h>
 
 /**
  * Currently we use a spinlock for the lock, but a mutex *may* be
@@ -108,9 +108,12 @@ static int ttm_bo_man_init(struct ttm_mem_type_manager *man,
        int ret;
 
        rman = kmalloc(sizeof(*rman), M_TTM_RMAN, M_ZERO | M_WAITOK);
+       if (!rman)
+               return -ENOMEM;
+
        ret = drm_mm_init(&rman->mm, 0, p_size);
        if (ret) {
-               drm_free(rman, M_TTM_RMAN);
+               kfree(rman, M_TTM_RMAN);
                return ret;
        }
 
@@ -128,8 +131,7 @@ static int ttm_bo_man_takedown(struct ttm_mem_type_manager *man)
        if (drm_mm_clean(mm)) {
                drm_mm_takedown(mm);
                lockmgr(&rman->lock, LK_RELEASE);
-               lockuninit(&rman->lock);
-               drm_free(rman, M_TTM_RMAN);
+               kfree(rman, M_TTM_RMAN);
                man->priv = NULL;
                return 0;
        }
@@ -154,3 +156,4 @@ const struct ttm_mem_type_manager_func ttm_bo_manager_func = {
        ttm_bo_man_put_node,
        ttm_bo_man_debug
 };
+EXPORT_SYMBOL(ttm_bo_manager_func);
index 11001e3..2030146 100644 (file)
  **************************************************************************/
 /*
  * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
- *
- * $FreeBSD: head/sys/dev/drm2/ttm/ttm_bo_util.c 248666 2013-03-23 22:23:15Z kib $
  */
 
-#include <drm/drmP.h>
 #include <drm/ttm/ttm_bo_driver.h>
 #include <drm/ttm/ttm_placement.h>
 #include <sys/sfbuf.h>
+#include <linux/export.h>
 
 void ttm_bo_free_old_node(struct ttm_buffer_object *bo)
 {
@@ -71,6 +69,7 @@ int ttm_bo_move_ttm(struct ttm_buffer_object *bo,
 
        return 0;
 }
+EXPORT_SYMBOL(ttm_bo_move_ttm);
 
 int ttm_mem_io_lock(struct ttm_mem_type_manager *man, bool interruptible)
 {
@@ -261,7 +260,7 @@ static int ttm_copy_io_ttm_page(struct ttm_tt *ttm, void *src,
        if (!dst)
                return -ENOMEM;
 
-       memcpy(dst, src, PAGE_SIZE);
+       memcpy_fromio(dst, src, PAGE_SIZE);
 
        pmap_unmapdev((vm_offset_t)dst, PAGE_SIZE);
 
@@ -283,7 +282,7 @@ static int ttm_copy_ttm_io_page(struct ttm_tt *ttm, void *dst,
        if (!src)
                return -ENOMEM;
 
-       memcpy(dst, src, PAGE_SIZE);
+       memcpy_toio(dst, src, PAGE_SIZE);
 
        pmap_unmapdev((vm_offset_t)src, PAGE_SIZE);
 
@@ -375,12 +374,13 @@ out:
        ttm_bo_mem_put(bo, &old_copy);
        return ret;
 }
+EXPORT_SYMBOL(ttm_bo_move_memcpy);
 
 MALLOC_DEFINE(M_TTM_TRANSF_OBJ, "ttm_transf_obj", "TTM Transfer Objects");
 
 static void ttm_transfered_destroy(struct ttm_buffer_object *bo)
 {
-       drm_free(bo, M_TTM_TRANSF_OBJ);
+       kfree(bo, M_TTM_TRANSF_OBJ);
 }
 
 /**
@@ -398,15 +398,17 @@ static void ttm_transfered_destroy(struct ttm_buffer_object *bo)
  * !0: Failure.
  */
 
-static int
-ttm_buffer_object_transfer(struct ttm_buffer_object *bo,
-    struct ttm_buffer_object **new_obj)
+static int ttm_buffer_object_transfer(struct ttm_buffer_object *bo,
+                                     struct ttm_buffer_object **new_obj)
 {
        struct ttm_buffer_object *fbo;
        struct ttm_bo_device *bdev = bo->bdev;
        struct ttm_bo_driver *driver = bdev->driver;
 
        fbo = kmalloc(sizeof(*fbo), M_TTM_TRANSF_OBJ, M_WAITOK);
+       if (!fbo)
+               return -ENOMEM;
+
        *fbo = *bo;
 
        /**
@@ -439,7 +441,7 @@ ttm_buffer_object_transfer(struct ttm_buffer_object *bo,
 vm_memattr_t
 ttm_io_prot(uint32_t caching_flags)
 {
-#if defined(__i386__) || defined(__amd64__)
+#if defined(__i386__) || defined(__x86_64__)
        if (caching_flags & TTM_PL_FLAG_WC)
                return (VM_MEMATTR_WRITE_COMBINING);
        else
@@ -452,6 +454,7 @@ ttm_io_prot(uint32_t caching_flags)
 #error Port me
 #endif
 }
+EXPORT_SYMBOL(ttm_io_prot);
 
 static int ttm_bo_ioremap(struct ttm_buffer_object *bo,
                          unsigned long offset,
@@ -484,7 +487,7 @@ static int ttm_bo_kmap_ttm(struct ttm_buffer_object *bo,
        struct ttm_tt *ttm = bo->ttm;
        int i, ret;
 
-       KKASSERT(ttm != NULL);
+       BUG_ON(!ttm);
 
        if (ttm->state == tt_unpopulated) {
                ret = ttm->bdev->driver->ttm_tt_populate(ttm);
@@ -536,7 +539,7 @@ int ttm_bo_kmap(struct ttm_buffer_object *bo,
        unsigned long offset, size;
        int ret;
 
-       KKASSERT(list_empty(&bo->swap));
+       BUG_ON(!list_empty(&bo->swap));
        map->virtual = NULL;
        map->bo = bo;
        if (num_pages > bo->num_pages)
@@ -560,6 +563,7 @@ int ttm_bo_kmap(struct ttm_buffer_object *bo,
                return ttm_bo_ioremap(bo, offset, size, map);
        }
 }
+EXPORT_SYMBOL(ttm_bo_kmap);
 
 void ttm_bo_kunmap(struct ttm_bo_kmap_obj *map)
 {
@@ -584,7 +588,7 @@ void ttm_bo_kunmap(struct ttm_bo_kmap_obj *map)
        case ttm_bo_map_premapped:
                break;
        default:
-               KKASSERT(0);
+               BUG();
        }
        (void) ttm_mem_io_lock(man, false);
        ttm_mem_io_free(map->bo->bdev, &map->bo->mem);
@@ -593,6 +597,7 @@ void ttm_bo_kunmap(struct ttm_bo_kmap_obj *map)
        map->page = NULL;
        map->sf = NULL;
 }
+EXPORT_SYMBOL(ttm_bo_kunmap);
 
 int ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo,
                              void *sync_obj,
@@ -667,3 +672,4 @@ int ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo,
 
        return 0;
 }
+EXPORT_SYMBOL(ttm_bo_move_accel_cleanup);
index 2f496f5..d20c3e3 100644 (file)
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
- * $FreeBSD: head/sys/dev/drm2/ttm/ttm_execbuf_util.c 247835 2013-03-05 09:49:34Z kib $
  **************************************************************************/
 
-#include <drm/drmP.h>
 #include <drm/ttm/ttm_execbuf_util.h>
 #include <drm/ttm/ttm_bo_driver.h>
 #include <drm/ttm/ttm_placement.h>
+#include <linux/export.h>
 
 static void ttm_eu_backoff_reservation_locked(struct list_head *list)
 {
@@ -95,6 +94,7 @@ void ttm_eu_backoff_reservation(struct list_head *list)
        ttm_eu_backoff_reservation_locked(list);
        lockmgr(&glob->lru_lock, LK_RELEASE);
 }
+EXPORT_SYMBOL(ttm_eu_backoff_reservation);
 
 /*
  * Reserve buffers for validation.
@@ -130,7 +130,7 @@ int ttm_eu_reserve_buffers(struct list_head *list)
        lockmgr(&glob->lru_lock, LK_EXCLUSIVE);
        val_seq = entry->bo->bdev->val_seq++;
 
-retry_locked:
+retry:
        list_for_each_entry(entry, list, head) {
                struct ttm_buffer_object *bo = entry->bo;
 
@@ -144,8 +144,10 @@ retry_locked:
                        break;
                case -EBUSY:
                        ttm_eu_del_from_lru_locked(list);
+                       lockmgr(&glob->lru_lock, LK_RELEASE);
                        ret = ttm_bo_reserve_nolru(bo, true, false,
                                                   true, val_seq);
+                       lockmgr(&glob->lru_lock, LK_EXCLUSIVE);
                        if (!ret)
                                break;
 
@@ -164,18 +166,18 @@ retry_locked:
                         */
                        val_seq = entry->bo->bdev->val_seq++;
 
+                       lockmgr(&glob->lru_lock, LK_RELEASE);
                        ttm_eu_list_ref_sub(list);
                        ret = ttm_bo_reserve_slowpath_nolru(bo, true, val_seq);
-                       if (unlikely(ret != 0)) {
-                               lockmgr(&glob->lru_lock, LK_RELEASE);
+                       if (unlikely(ret != 0))
                                return ret;
-                       }
+                       lockmgr(&glob->lru_lock, LK_EXCLUSIVE);
                        entry->reserved = true;
                        if (unlikely(atomic_read(&bo->cpu_writers) > 0)) {
                                ret = -EBUSY;
                                goto err;
                        }
-                       goto retry_locked;
+                       goto retry;
                default:
                        goto err;
                }
@@ -199,6 +201,7 @@ err:
        ttm_eu_list_ref_sub(list);
        return ret;
 }
+EXPORT_SYMBOL(ttm_eu_reserve_buffers);
 
 void ttm_eu_fence_buffer_objects(struct list_head *list, void *sync_obj)
 {
@@ -234,3 +237,4 @@ void ttm_eu_fence_buffer_objects(struct list_head *list, void *sync_obj)
                        driver->sync_obj_unref(&entry->old_sync_obj);
        }
 }
+EXPORT_SYMBOL(ttm_eu_fence_buffer_objects);
index 8d2c2e6..c70c140 100644 (file)
@@ -39,6 +39,8 @@
 
 #include <drm/ttm/ttm_lock.h>
 #include <drm/ttm/ttm_module.h>
+#include <linux/atomic.h>
+#include <linux/export.h>
 
 #define TTM_WRITE_LOCK_PENDING    (1 << 0)
 #define TTM_VT_LOCK_PENDING       (1 << 1)
@@ -54,6 +56,7 @@ void ttm_lock_init(struct ttm_lock *lock)
        lock->kill_takers = false;
        lock->signal = SIGKILL;
 }
+EXPORT_SYMBOL(ttm_lock_init);
 
 static void
 ttm_lock_send_sig(int signo)
@@ -73,24 +76,27 @@ void ttm_read_unlock(struct ttm_lock *lock)
                wakeup(lock);
        lockmgr(&lock->lock, LK_RELEASE);
 }
+EXPORT_SYMBOL(ttm_read_unlock);
 
 static bool __ttm_read_lock(struct ttm_lock *lock)
 {
        bool locked = false;
 
+       lockmgr(&lock->lock, LK_EXCLUSIVE);
        if (unlikely(lock->kill_takers)) {
                ttm_lock_send_sig(lock->signal);
+               lockmgr(&lock->lock, LK_RELEASE);
                return false;
        }
        if (lock->rw >= 0 && lock->flags == 0) {
                ++lock->rw;
                locked = true;
        }
+       lockmgr(&lock->lock, LK_RELEASE);
        return locked;
 }
 
-int
-ttm_read_lock(struct ttm_lock *lock, bool interruptible)
+int ttm_read_lock(struct ttm_lock *lock, bool interruptible)
 {
        const char *wmsg;
        int flags, ret;
@@ -111,6 +117,7 @@ ttm_read_lock(struct ttm_lock *lock, bool interruptible)
        }
        return (-ret);
 }
+EXPORT_SYMBOL(ttm_read_lock);
 
 static bool __ttm_read_trylock(struct ttm_lock *lock, bool *locked)
 {
@@ -118,8 +125,10 @@ static bool __ttm_read_trylock(struct ttm_lock *lock, bool *locked)
 
        *locked = false;
 
+       lockmgr(&lock->lock, LK_EXCLUSIVE);
        if (unlikely(lock->kill_takers)) {
                ttm_lock_send_sig(lock->signal);
+               lockmgr(&lock->lock, LK_RELEASE);
                return false;
        }
        if (lock->rw >= 0 && lock->flags == 0) {
@@ -129,6 +138,7 @@ static bool __ttm_read_trylock(struct ttm_lock *lock, bool *locked)
        } else if (lock->flags == 0) {
                block = false;
        }
+       lockmgr(&lock->lock, LK_RELEASE);
 
        return !block;
 }
@@ -166,13 +176,16 @@ void ttm_write_unlock(struct ttm_lock *lock)
        wakeup(lock);
        lockmgr(&lock->lock, LK_RELEASE);
 }
+EXPORT_SYMBOL(ttm_write_unlock);
 
 static bool __ttm_write_lock(struct ttm_lock *lock)
 {
        bool locked = false;
 
+       lockmgr(&lock->lock, LK_EXCLUSIVE);
        if (unlikely(lock->kill_takers)) {
                ttm_lock_send_sig(lock->signal);
+               lockmgr(&lock->lock, LK_RELEASE);
                return false;
        }
        if (lock->rw == 0 && ((lock->flags & ~TTM_WRITE_LOCK_PENDING) == 0)) {
@@ -182,11 +195,11 @@ static bool __ttm_write_lock(struct ttm_lock *lock)
        } else {
                lock->flags |= TTM_WRITE_LOCK_PENDING;
        }
+       lockmgr(&lock->lock, LK_RELEASE);
        return locked;
 }
 
-int
-ttm_write_lock(struct ttm_lock *lock, bool interruptible)
+int ttm_write_lock(struct ttm_lock *lock, bool interruptible)
 {
        const char *wmsg;
        int flags, ret;
@@ -213,6 +226,7 @@ ttm_write_lock(struct ttm_lock *lock, bool interruptible)
 
        return (-ret);
 }
+EXPORT_SYMBOL(ttm_write_lock);
 
 void ttm_write_lock_downgrade(struct ttm_lock *lock)
 {
@@ -244,13 +258,14 @@ static void ttm_vt_lock_remove(struct ttm_base_object **p_base)
 
        *p_base = NULL;
        ret = __ttm_vt_unlock(lock);
-       KKASSERT(ret == 0);
+       BUG_ON(ret != 0);
 }
 
 static bool __ttm_vt_lock(struct ttm_lock *lock)
 {
        bool locked = false;
 
+       lockmgr(&lock->lock, LK_EXCLUSIVE);
        if (lock->rw == 0) {
                lock->flags &= ~TTM_VT_LOCK_PENDING;
                lock->flags |= TTM_VT_LOCK;
@@ -258,6 +273,7 @@ static bool __ttm_vt_lock(struct ttm_lock *lock)
        } else {
                lock->flags |= TTM_VT_LOCK_PENDING;
        }
+       lockmgr(&lock->lock, LK_RELEASE);
        return locked;
 }
 
@@ -301,12 +317,14 @@ int ttm_vt_lock(struct ttm_lock *lock,
 
        return (-ret);
 }
+EXPORT_SYMBOL(ttm_vt_lock);
 
 int ttm_vt_unlock(struct ttm_lock *lock)
 {
        return ttm_ref_object_base_unref(lock->vt_holder,
                                         lock->base.hash.key, TTM_REF_USAGE);
 }
+EXPORT_SYMBOL(ttm_vt_unlock);
 
 void ttm_suspend_unlock(struct ttm_lock *lock)
 {
@@ -315,11 +333,13 @@ void ttm_suspend_unlock(struct ttm_lock *lock)
        wakeup(lock);
        lockmgr(&lock->lock, LK_RELEASE);
 }
+EXPORT_SYMBOL(ttm_suspend_unlock);
 
 static bool __ttm_suspend_lock(struct ttm_lock *lock)
 {
        bool locked = false;
 
+       lockmgr(&lock->lock, LK_EXCLUSIVE);
        if (lock->rw == 0) {
                lock->flags &= ~TTM_SUSPEND_LOCK_PENDING;
                lock->flags |= TTM_SUSPEND_LOCK;
@@ -327,6 +347,7 @@ static bool __ttm_suspend_lock(struct ttm_lock *lock)
        } else {
                lock->flags |= TTM_SUSPEND_LOCK_PENDING;
        }
+       lockmgr(&lock->lock, LK_RELEASE);
        return locked;
 }
 
@@ -337,3 +358,4 @@ void ttm_suspend_lock(struct ttm_lock *lock)
                lksleep(lock, &lock->lock, 0, "ttms", 0);
        lockmgr(&lock->lock, LK_RELEASE);
 }
+EXPORT_SYMBOL(ttm_suspend_lock);
index 890f03c..22e4225 100644 (file)
@@ -30,6 +30,7 @@
 #include <drm/ttm/ttm_memory.h>
 #include <drm/ttm/ttm_module.h>
 #include <drm/ttm/ttm_page_alloc.h>
+#include <linux/export.h>
 
 #define TTM_MEMORY_ALLOC_RETRIES 4
 
@@ -279,6 +280,7 @@ out_no_zone:
        ttm_mem_global_release(glob);
        return ret;
 }
+EXPORT_SYMBOL(ttm_mem_global_init);
 
 void ttm_mem_global_release(struct ttm_mem_global *glob)
 {
@@ -300,6 +302,7 @@ void ttm_mem_global_release(struct ttm_mem_global *glob)
        if (refcount_release(&glob->kobj_ref))
                ttm_mem_global_kobj_release(glob);
 }
+EXPORT_SYMBOL(ttm_mem_global_release);
 
 static void ttm_check_swapping(struct ttm_mem_global *glob)
 {
@@ -344,6 +347,7 @@ void ttm_mem_global_free(struct ttm_mem_global *glob,
 {
        ttm_mem_global_free_zone(glob, NULL, amount);
 }
+EXPORT_SYMBOL(ttm_mem_global_free);
 
 static int ttm_mem_global_reserve(struct ttm_mem_global *glob,
                                  struct ttm_mem_zone *single_zone,
@@ -417,6 +421,7 @@ int ttm_mem_global_alloc(struct ttm_mem_global *glob, uint64_t memory,
        return ttm_mem_global_alloc_zone(glob, NULL, memory, no_wait,
                                         interruptible);
 }
+EXPORT_SYMBOL(ttm_mem_global_alloc);
 
 #define page_to_pfn(pp) OFF_TO_IDX(VM_PAGE_TO_PHYS(pp))
 
@@ -464,3 +469,4 @@ size_t ttm_round_pot(size_t size)
        }
        return 0;
 }
+EXPORT_SYMBOL(ttm_round_pot);
diff --git a/sys/dev/drm/ttm/ttm_page_alloc_dma.c b/sys/dev/drm/ttm/ttm_page_alloc_dma.c
deleted file mode 100644 (file)
index aeeb208..0000000
+++ /dev/null
@@ -1,1133 +0,0 @@
-/*
- * Copyright 2011 (c) Oracle Corp.
-
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sub license,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Author: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
- *
- * $FreeBSD: head/sys/dev/drm2/ttm/ttm_page_alloc_dma.c 247835 2013-03-05 09:49:34Z kib $
- */
-
-/*
- * A simple DMA pool losely based on dmapool.c. It has certain advantages
- * over the DMA pools:
- * - Pool collects resently freed pages for reuse (and hooks up to
- *   the shrinker).
- * - Tracks currently in use pages
- * - Tracks whether the page is UC, WB or cached (and reverts to WB
- *   when freed).
- */
-
-#define pr_fmt(fmt) "[TTM] " fmt
-
-#include <linux/dma-mapping.h>
-#include <linux/list.h>
-#include <linux/seq_file.h> /* for seq_printf */
-#include <linux/slab.h>
-#include <linux/spinlock.h>
-#include <linux/highmem.h>
-#include <linux/mm_types.h>
-#include <linux/module.h>
-#include <linux/mm.h>
-#include <linux/atomic.h>
-#include <linux/device.h>
-#include <linux/kthread.h>
-#include <drm/ttm/ttm_bo_driver.h>
-#include <drm/ttm/ttm_page_alloc.h>
-#ifdef TTM_HAS_AGP
-#include <asm/agp.h>
-#endif
-
-#define NUM_PAGES_TO_ALLOC             (PAGE_SIZE/sizeof(struct page *))
-#define SMALL_ALLOCATION               4
-#define FREE_ALL_PAGES                 (~0U)
-/* times are in msecs */
-#define IS_UNDEFINED                   (0)
-#define IS_WC                          (1<<1)
-#define IS_UC                          (1<<2)
-#define IS_CACHED                      (1<<3)
-#define IS_DMA32                       (1<<4)
-
-enum pool_type {
-       POOL_IS_UNDEFINED,
-       POOL_IS_WC = IS_WC,
-       POOL_IS_UC = IS_UC,
-       POOL_IS_CACHED = IS_CACHED,
-       POOL_IS_WC_DMA32 = IS_WC | IS_DMA32,
-       POOL_IS_UC_DMA32 = IS_UC | IS_DMA32,
-       POOL_IS_CACHED_DMA32 = IS_CACHED | IS_DMA32,
-};
-/*
- * The pool structure. There are usually six pools:
- *  - generic (not restricted to DMA32):
- *      - write combined, uncached, cached.
- *  - dma32 (up to 2^32 - so up 4GB):
- *      - write combined, uncached, cached.
- * for each 'struct device'. The 'cached' is for pages that are actively used.
- * The other ones can be shrunk by the shrinker API if neccessary.
- * @pools: The 'struct device->dma_pools' link.
- * @type: Type of the pool
- * @lock: Protects the inuse_list and free_list from concurrnet access. Must be
- * used with irqsave/irqrestore variants because pool allocator maybe called
- * from delayed work.
- * @inuse_list: Pool of pages that are in use. The order is very important and
- *   it is in the order that the TTM pages that are put back are in.
- * @free_list: Pool of pages that are free to be used. No order requirements.
- * @dev: The device that is associated with these pools.
- * @size: Size used during DMA allocation.
- * @npages_free: Count of available pages for re-use.
- * @npages_in_use: Count of pages that are in use.
- * @nfrees: Stats when pool is shrinking.
- * @nrefills: Stats when the pool is grown.
- * @gfp_flags: Flags to pass for alloc_page.
- * @name: Name of the pool.
- * @dev_name: Name derieved from dev - similar to how dev_info works.
- *   Used during shutdown as the dev_info during release is unavailable.
- */
-struct dma_pool {
-       struct list_head pools; /* The 'struct device->dma_pools link */
-       enum pool_type type;
-       spinlock_t lock;
-       struct list_head inuse_list;
-       struct list_head free_list;
-       struct device *dev;
-       unsigned size;
-       unsigned npages_free;
-       unsigned npages_in_use;
-       unsigned long nfrees; /* Stats when shrunk. */
-       unsigned long nrefills; /* Stats when grown. */
-       gfp_t gfp_flags;
-       char name[13]; /* "cached dma32" */
-       char dev_name[64]; /* Constructed from dev */
-};
-
-/*
- * The accounting page keeping track of the allocated page along with
- * the DMA address.
- * @page_list: The link to the 'page_list' in 'struct dma_pool'.
- * @vaddr: The virtual address of the page
- * @dma: The bus address of the page. If the page is not allocated
- *   via the DMA API, it will be -1.
- */
-struct dma_page {
-       struct list_head page_list;
-       void *vaddr;
-       struct page *p;
-       dma_addr_t dma;
-};
-
-/*
- * Limits for the pool. They are handled without locks because only place where
- * they may change is in sysfs store. They won't have immediate effect anyway
- * so forcing serialization to access them is pointless.
- */
-
-struct ttm_pool_opts {
-       unsigned        alloc_size;
-       unsigned        max_size;
-       unsigned        small;
-};
-
-/*
- * Contains the list of all of the 'struct device' and their corresponding
- * DMA pools. Guarded by _mutex->lock.
- * @pools: The link to 'struct ttm_pool_manager->pools'
- * @dev: The 'struct device' associated with the 'pool'
- * @pool: The 'struct dma_pool' associated with the 'dev'
- */
-struct device_pools {
-       struct list_head pools;
-       struct device *dev;
-       struct dma_pool *pool;
-};
-
-/*
- * struct ttm_pool_manager - Holds memory pools for fast allocation
- *
- * @lock: Lock used when adding/removing from pools
- * @pools: List of 'struct device' and 'struct dma_pool' tuples.
- * @options: Limits for the pool.
- * @npools: Total amount of pools in existence.
- * @shrinker: The structure used by [un|]register_shrinker
- */
-struct ttm_pool_manager {
-       struct mutex            lock;
-       struct list_head        pools;
-       struct ttm_pool_opts    options;
-       unsigned                npools;
-       struct shrinker         mm_shrink;
-       struct kobject          kobj;
-};
-
-static struct ttm_pool_manager *_manager;
-
-static struct attribute ttm_page_pool_max = {
-       .name = "pool_max_size",
-       .mode = S_IRUGO | S_IWUSR
-};
-static struct attribute ttm_page_pool_small = {
-       .name = "pool_small_allocation",
-       .mode = S_IRUGO | S_IWUSR
-};
-static struct attribute ttm_page_pool_alloc_size = {
-       .name = "pool_allocation_size",
-       .mode = S_IRUGO | S_IWUSR
-};
-
-static struct attribute *ttm_pool_attrs[] = {
-       &ttm_page_pool_max,
-       &ttm_page_pool_small,
-       &ttm_page_pool_alloc_size,
-       NULL
-};
-
-static void ttm_pool_kobj_release(struct kobject *kobj)
-{
-       struct ttm_pool_manager *m =
-               container_of(kobj, struct ttm_pool_manager, kobj);
-       kfree(m);
-}
-
-static ssize_t ttm_pool_store(struct kobject *kobj, struct attribute *attr,
-                             const char *buffer, size_t size)
-{
-       struct ttm_pool_manager *m =
-               container_of(kobj, struct ttm_pool_manager, kobj);
-       int chars;
-       unsigned val;
-       chars = sscanf(buffer, "%u", &val);
-       if (chars == 0)
-               return size;
-
-       /* Convert kb to number of pages */
-       val = val / (PAGE_SIZE >> 10);
-
-       if (attr == &ttm_page_pool_max)
-               m->options.max_size = val;
-       else if (attr == &ttm_page_pool_small)
-               m->options.small = val;
-       else if (attr == &ttm_page_pool_alloc_size) {
-               if (val > NUM_PAGES_TO_ALLOC*8) {
-                       pr_err("Setting allocation size to %lu is not allowed. Recommended size is %lu\n",
-                              NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 7),
-                              NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 10));
-                       return size;
-               } else if (val > NUM_PAGES_TO_ALLOC) {
-                       pr_warn("Setting allocation size to larger than %lu is not recommended\n",
-                               NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 10));
-               }
-               m->options.alloc_size = val;
-       }
-
-       return size;
-}
-
-static ssize_t ttm_pool_show(struct kobject *kobj, struct attribute *attr,
-                            char *buffer)
-{
-       struct ttm_pool_manager *m =
-               container_of(kobj, struct ttm_pool_manager, kobj);
-       unsigned val = 0;
-
-       if (attr == &ttm_page_pool_max)
-               val = m->options.max_size;
-       else if (attr == &ttm_page_pool_small)
-               val = m->options.small;
-       else if (attr == &ttm_page_pool_alloc_size)
-               val = m->options.alloc_size;
-
-       val = val * (PAGE_SIZE >> 10);
-
-       return snprintf(buffer, PAGE_SIZE, "%u\n", val);
-}
-
-static const struct sysfs_ops ttm_pool_sysfs_ops = {
-       .show = &ttm_pool_show,
-       .store = &ttm_pool_store,
-};
-
-static struct kobj_type ttm_pool_kobj_type = {
-       .release = &ttm_pool_kobj_release,
-       .sysfs_ops = &ttm_pool_sysfs_ops,
-       .default_attrs = ttm_pool_attrs,
-};
-
-#ifndef CONFIG_X86
-static int set_pages_array_wb(struct page **pages, int addrinarray)
-{
-#ifdef TTM_HAS_AGP
-       int i;
-
-       for (i = 0; i < addrinarray; i++)
-               unmap_page_from_agp(pages[i]);
-#endif
-       return 0;
-}
-
-static int set_pages_array_wc(struct page **pages, int addrinarray)
-{
-#ifdef TTM_HAS_AGP
-       int i;
-
-       for (i = 0; i < addrinarray; i++)
-               map_page_into_agp(pages[i]);
-#endif
-       return 0;
-}
-
-static int set_pages_array_uc(struct page **pages, int addrinarray)
-{
-#ifdef TTM_HAS_AGP
-       int i;
-
-       for (i = 0; i < addrinarray; i++)
-               map_page_into_agp(pages[i]);
-#endif
-       return 0;
-}
-#endif /* for !CONFIG_X86 */
-
-static int ttm_set_pages_caching(struct dma_pool *pool,
-                                struct page **pages, unsigned cpages)
-{
-       int r = 0;
-       /* Set page caching */
-       if (pool->type & IS_UC) {
-               r = set_pages_array_uc(pages, cpages);
-               if (r)
-                       pr_err("%s: Failed to set %d pages to uc!\n",
-                              pool->dev_name, cpages);
-       }
-       if (pool->type & IS_WC) {
-               r = set_pages_array_wc(pages, cpages);
-               if (r)
-                       pr_err("%s: Failed to set %d pages to wc!\n",
-                              pool->dev_name, cpages);
-       }
-       return r;
-}
-
-static void __ttm_dma_free_page(struct dma_pool *pool, struct dma_page *d_page)
-{
-       dma_addr_t dma = d_page->dma;
-       dma_free_coherent(pool->dev, pool->size, d_page->vaddr, dma);
-
-       kfree(d_page);
-       d_page = NULL;
-}
-static struct dma_page *__ttm_dma_alloc_page(struct dma_pool *pool)
-{
-       struct dma_page *d_page;
-
-       d_page = kmalloc(sizeof(struct dma_page), GFP_KERNEL);
-       if (!d_page)
-               return NULL;
-
-       d_page->vaddr = dma_alloc_coherent(pool->dev, pool->size,
-                                          &d_page->dma,
-                                          pool->gfp_flags);
-       if (d_page->vaddr)
-               d_page->p = virt_to_page(d_page->vaddr);
-       else {
-               kfree(d_page);
-               d_page = NULL;
-       }
-       return d_page;
-}
-static enum pool_type ttm_to_type(int flags, enum ttm_caching_state cstate)
-{
-       enum pool_type type = IS_UNDEFINED;
-
-       if (flags & TTM_PAGE_FLAG_DMA32)
-               type |= IS_DMA32;
-       if (cstate == tt_cached)
-               type |= IS_CACHED;
-       else if (cstate == tt_uncached)
-               type |= IS_UC;
-       else
-               type |= IS_WC;
-
-       return type;
-}
-
-static void ttm_pool_update_free_locked(struct dma_pool *pool,
-                                       unsigned freed_pages)
-{
-       pool->npages_free -= freed_pages;
-       pool->nfrees += freed_pages;
-
-}
-
-/* set memory back to wb and free the pages. */
-static void ttm_dma_pages_put(struct dma_pool *pool, struct list_head *d_pages,
-                             struct page *pages[], unsigned npages)
-{
-       struct dma_page *d_page, *tmp;
-
-       /* Don't set WB on WB page pool. */
-       if (npages && !(pool->type & IS_CACHED) &&
-           set_pages_array_wb(pages, npages))
-               pr_err("%s: Failed to set %d pages to wb!\n",
-                      pool->dev_name, npages);
-
-       list_for_each_entry_safe(d_page, tmp, d_pages, page_list) {
-               list_del(&d_page->page_list);
-               __ttm_dma_free_page(pool, d_page);
-       }
-}
-
-static void ttm_dma_page_put(struct dma_pool *pool, struct dma_page *d_page)
-{
-       /* Don't set WB on WB page pool. */
-       if (!(pool->type & IS_CACHED) && set_pages_array_wb(&d_page->p, 1))
-               pr_err("%s: Failed to set %d pages to wb!\n",
-                      pool->dev_name, 1);
-
-       list_del(&d_page->page_list);
-       __ttm_dma_free_page(pool, d_page);
-}
-
-/*
- * Free pages from pool.
- *
- * To prevent hogging the ttm_swap process we only free NUM_PAGES_TO_ALLOC
- * number of pages in one go.
- *
- * @pool: to free the pages from
- * @nr_free: If set to true will free all pages in pool
- **/
-static unsigned ttm_dma_page_pool_free(struct dma_pool *pool, unsigned nr_free)
-{
-       unsigned long irq_flags;
-       struct dma_page *dma_p, *tmp;
-       struct page **pages_to_free;
-       struct list_head d_pages;
-       unsigned freed_pages = 0,
-                npages_to_free = nr_free;
-
-       if (NUM_PAGES_TO_ALLOC < nr_free)
-               npages_to_free = NUM_PAGES_TO_ALLOC;
-#if 0
-       if (nr_free > 1) {
-               pr_debug("%s: (%s:%d) Attempting to free %d (%d) pages\n",
-                        pool->dev_name, pool->name, current->pid,
-                        npages_to_free, nr_free);
-       }
-#endif
-       pages_to_free = kmalloc(npages_to_free * sizeof(struct page *),
-                       GFP_KERNEL);
-
-       if (!pages_to_free) {
-               pr_err("%s: Failed to allocate memory for pool free operation\n",
-                      pool->dev_name);
-               return 0;
-       }
-       INIT_LIST_HEAD(&d_pages);
-restart:
-       spin_lock_irqsave(&pool->lock, irq_flags);
-
-       /* We picking the oldest ones off the list */
-       list_for_each_entry_safe_reverse(dma_p, tmp, &pool->free_list,
-                                        page_list) {
-               if (freed_pages >= npages_to_free)
-                       break;
-
-               /* Move the dma_page from one list to another. */
-               list_move(&dma_p->page_list, &d_pages);
-
-               pages_to_free[freed_pages++] = dma_p->p;
-               /* We can only remove NUM_PAGES_TO_ALLOC at a time. */
-               if (freed_pages >= NUM_PAGES_TO_ALLOC) {
-
-                       ttm_pool_update_free_locked(pool, freed_pages);
-                       /**
-                        * Because changing page caching is costly
-                        * we unlock the pool to prevent stalling.
-                        */
-                       spin_unlock_irqrestore(&pool->lock, irq_flags);
-
-                       ttm_dma_pages_put(pool, &d_pages, pages_to_free,
-                                         freed_pages);
-
-                       INIT_LIST_HEAD(&d_pages);
-
-                       if (likely(nr_free != FREE_ALL_PAGES))
-                               nr_free -= freed_pages;
-
-                       if (NUM_PAGES_TO_ALLOC >= nr_free)
-                               npages_to_free = nr_free;
-                       else
-                               npages_to_free = NUM_PAGES_TO_ALLOC;
-
-                       freed_pages = 0;
-
-                       /* free all so restart the processing */
-                       if (nr_free)
-                               goto restart;
-
-                       /* Not allowed to fall through or break because
-                        * following context is inside spinlock while we are
-                        * outside here.
-                        */
-                       goto out;
-
-               }
-       }
-
-       /* remove range of pages from the pool */
-       if (freed_pages) {
-               ttm_pool_update_free_locked(pool, freed_pages);
-               nr_free -= freed_pages;
-       }
-
-       spin_unlock_irqrestore(&pool->lock, irq_flags);
-
-       if (freed_pages)
-               ttm_dma_pages_put(pool, &d_pages, pages_to_free, freed_pages);
-out:
-       kfree(pages_to_free);
-       return nr_free;
-}
-
-static void ttm_dma_free_pool(struct device *dev, enum pool_type type)
-{
-       struct device_pools *p;
-       struct dma_pool *pool;
-
-       if (!dev)
-               return;
-
-       mutex_lock(&_manager->lock);
-       list_for_each_entry_reverse(p, &_manager->pools, pools) {
-               if (p->dev != dev)
-                       continue;
-               pool = p->pool;
-               if (pool->type != type)
-                       continue;
-
-               list_del(&p->pools);
-               kfree(p);
-               _manager->npools--;
-               break;
-       }
-       list_for_each_entry_reverse(pool, &dev->dma_pools, pools) {
-               if (pool->type != type)
-                       continue;
-               /* Takes a spinlock.. */
-               ttm_dma_page_pool_free(pool, FREE_ALL_PAGES);
-               WARN_ON(((pool->npages_in_use + pool->npages_free) != 0));
-               /* This code path is called after _all_ references to the
-                * struct device has been dropped - so nobody should be
-                * touching it. In case somebody is trying to _add_ we are
-                * guarded by the mutex. */
-               list_del(&pool->pools);
-               kfree(pool);
-               break;
-       }
-       mutex_unlock(&_manager->lock);
-}
-
-/*
- * On free-ing of the 'struct device' this deconstructor is run.
- * Albeit the pool might have already been freed earlier.
- */
-static void ttm_dma_pool_release(struct device *dev, void *res)
-{
-       struct dma_pool *pool = *(struct dma_pool **)res;
-
-       if (pool)
-               ttm_dma_free_pool(dev, pool->type);
-}
-
-static int ttm_dma_pool_match(struct device *dev, void *res, void *match_data)
-{
-       return *(struct dma_pool **)res == match_data;
-}
-
-static struct dma_pool *ttm_dma_pool_init(struct device *dev, gfp_t flags,
-                                         enum pool_type type)
-{
-       char *n[] = {"wc", "uc", "cached", " dma32", "unknown",};
-       enum pool_type t[] = {IS_WC, IS_UC, IS_CACHED, IS_DMA32, IS_UNDEFINED};
-       struct device_pools *sec_pool = NULL;
-       struct dma_pool *pool = NULL, **ptr;
-       unsigned i;
-       int ret = -ENODEV;
-       char *p;
-
-       if (!dev)
-               return NULL;
-
-       ptr = devres_alloc(ttm_dma_pool_release, sizeof(*ptr), GFP_KERNEL);
-       if (!ptr)
-               return NULL;
-
-       ret = -ENOMEM;
-
-       pool = kmalloc_node(sizeof(struct dma_pool), GFP_KERNEL,
-                           dev_to_node(dev));
-       if (!pool)
-               goto err_mem;
-
-       sec_pool = kmalloc_node(sizeof(struct device_pools), GFP_KERNEL,
-                               dev_to_node(dev));
-       if (!sec_pool)
-               goto err_mem;
-
-       INIT_LIST_HEAD(&sec_pool->pools);
-       sec_pool->dev = dev;
-       sec_pool->pool =  pool;
-
-       INIT_LIST_HEAD(&pool->free_list);
-       INIT_LIST_HEAD(&pool->inuse_list);
-       INIT_LIST_HEAD(&pool->pools);
-       spin_lock_init(&pool->lock);
-       pool->dev = dev;
-       pool->npages_free = pool->npages_in_use = 0;
-       pool->nfrees = 0;
-       pool->gfp_flags = flags;
-       pool->size = PAGE_SIZE;
-       pool->type = type;
-       pool->nrefills = 0;
-       p = pool->name;
-       for (i = 0; i < 5; i++) {
-               if (type & t[i]) {
-                       p += snprintf(p, sizeof(pool->name) - (p - pool->name),
-                                     "%s", n[i]);
-               }
-       }
-       *p = 0;
-       /* We copy the name for pr_ calls b/c when dma_pool_destroy is called
-        * - the kobj->name has already been deallocated.*/
-       snprintf(pool->dev_name, sizeof(pool->dev_name), "%s %s",
-                dev_driver_string(dev), dev_name(dev));
-       mutex_lock(&_manager->lock);
-       /* You can get the dma_pool from either the global: */
-       list_add(&sec_pool->pools, &_manager->pools);
-       _manager->npools++;
-       /* or from 'struct device': */
-       list_add(&pool->pools, &dev->dma_pools);
-       mutex_unlock(&_manager->lock);
-
-       *ptr = pool;
-       devres_add(dev, ptr);
-
-       return pool;
-err_mem:
-       devres_free(ptr);
-       kfree(sec_pool);
-       kfree(pool);
-       return ERR_PTR(ret);
-}
-
-static struct dma_pool *ttm_dma_find_pool(struct device *dev,
-                                         enum pool_type type)
-{
-       struct dma_pool *pool, *tmp, *found = NULL;
-
-       if (type == IS_UNDEFINED)
-               return found;
-
-       /* NB: We iterate on the 'struct dev' which has no spinlock, but
-        * it does have a kref which we have taken. The kref is taken during
-        * graphic driver loading - in the drm_pci_init it calls either
-        * pci_dev_get or pci_register_driver which both end up taking a kref
-        * on 'struct device'.
-        *
-        * On teardown, the graphic drivers end up quiescing the TTM (put_pages)
-        * and calls the dev_res deconstructors: ttm_dma_pool_release. The nice
-        * thing is at that point of time there are no pages associated with the
-        * driver so this function will not be called.
-        */
-       list_for_each_entry_safe(pool, tmp, &dev->dma_pools, pools) {
-               if (pool->type != type)
-                       continue;
-               found = pool;
-               break;
-       }
-       return found;
-}
-
-/*
- * Free pages the pages that failed to change the caching state. If there
- * are pages that have changed their caching state already put them to the
- * pool.
- */
-static void ttm_dma_handle_caching_state_failure(struct dma_pool *pool,
-                                                struct list_head *d_pages,
-                                                struct page **failed_pages,
-                                                unsigned cpages)
-{
-       struct dma_page *d_page, *tmp;
-       struct page *p;
-       unsigned i = 0;
-
-       p = failed_pages[0];
-       if (!p)
-               return;
-       /* Find the failed page. */
-       list_for_each_entry_safe(d_page, tmp, d_pages, page_list) {
-               if (d_page->p != p)
-                       continue;
-               /* .. and then progress over the full list. */
-               list_del(&d_page->page_list);
-               __ttm_dma_free_page(pool, d_page);
-               if (++i < cpages)
-                       p = failed_pages[i];
-               else
-                       break;
-       }
-
-}
-
-/*
- * Allocate 'count' pages, and put 'need' number of them on the
- * 'pages' and as well on the 'dma_address' starting at 'dma_offset' offset.
- * The full list of pages should also be on 'd_pages'.
- * We return zero for success, and negative numbers as errors.
- */
-static int ttm_dma_pool_alloc_new_pages(struct dma_pool *pool,
-                                       struct list_head *d_pages,
-                                       unsigned count)
-{
-       struct page **caching_array;
-       struct dma_page *dma_p;
-       struct page *p;
-       int r = 0;
-       unsigned i, cpages;
-       unsigned max_cpages = min(count,
-                       (unsigned)(PAGE_SIZE/sizeof(struct page *)));
-
-       /* allocate array for page caching change */
-       caching_array = kmalloc(max_cpages*sizeof(struct page *), GFP_KERNEL);
-
-       if (!caching_array) {
-               pr_err("%s: Unable to allocate table for new pages\n",
-                      pool->dev_name);
-               return -ENOMEM;
-       }
-
-       if (count > 1) {
-               pr_debug("%s: (%s:%d) Getting %d pages\n",
-                        pool->dev_name, pool->name, current->pid, count);
-       }
-
-       for (i = 0, cpages = 0; i < count; ++i) {
-               dma_p = __ttm_dma_alloc_page(pool);
-               if (!dma_p) {
-                       pr_err("%s: Unable to get page %u\n",
-                              pool->dev_name, i);
-
-                       /* store already allocated pages in the pool after
-                        * setting the caching state */
-                       if (cpages) {
-                               r = ttm_set_pages_caching(pool, caching_array,
-                                                         cpages);
-                               if (r)
-                                       ttm_dma_handle_caching_state_failure(
-                                               pool, d_pages, caching_array,
-                                               cpages);
-                       }
-                       r = -ENOMEM;
-                       goto out;
-               }
-               p = dma_p->p;
-#ifdef CONFIG_HIGHMEM
-               /* gfp flags of highmem page should never be dma32 so we
-                * we should be fine in such case
-                */
-               if (!PageHighMem(p))
-#endif
-               {
-                       caching_array[cpages++] = p;
-                       if (cpages == max_cpages) {
-                               /* Note: Cannot hold the spinlock */
-                               r = ttm_set_pages_caching(pool, caching_array,
-                                                cpages);
-                               if (r) {
-                                       ttm_dma_handle_caching_state_failure(
-                                               pool, d_pages, caching_array,
-                                               cpages);
-                                       goto out;
-                               }
-                               cpages = 0;
-                       }
-               }
-               list_add(&dma_p->page_list, d_pages);
-       }
-
-       if (cpages) {
-               r = ttm_set_pages_caching(pool, caching_array, cpages);
-               if (r)
-                       ttm_dma_handle_caching_state_failure(pool, d_pages,
-                                       caching_array, cpages);
-       }
-out:
-       kfree(caching_array);
-       return r;
-}
-
-/*
- * @return count of pages still required to fulfill the request.
- */
-static int ttm_dma_page_pool_fill_locked(struct dma_pool *pool,
-                                        unsigned long *irq_flags)
-{
-       unsigned count = _manager->options.small;
-       int r = pool->npages_free;
-
-       if (count > pool->npages_free) {
-               struct list_head d_pages;
-
-               INIT_LIST_HEAD(&d_pages);
-
-               spin_unlock_irqrestore(&pool->lock, *irq_flags);
-
-               /* Returns how many more are neccessary to fulfill the
-                * request. */
-               r = ttm_dma_pool_alloc_new_pages(pool, &d_pages, count);
-
-               spin_lock_irqsave(&pool->lock, *irq_flags);
-               if (!r) {
-                       /* Add the fresh to the end.. */
-                       list_splice(&d_pages, &pool->free_list);
-                       ++pool->nrefills;
-                       pool->npages_free += count;
-                       r = count;
-               } else {
-                       struct dma_page *d_page;
-                       unsigned cpages = 0;
-
-                       pr_err("%s: Failed to fill %s pool (r:%d)!\n",
-                              pool->dev_name, pool->name, r);
-
-                       list_for_each_entry(d_page, &d_pages, page_list) {
-                               cpages++;
-                       }
-                       list_splice_tail(&d_pages, &pool->free_list);
-                       pool->npages_free += cpages;
-                       r = cpages;
-               }
-       }
-       return r;
-}
-
-/*
- * @return count of pages still required to fulfill the request.
- * The populate list is actually a stack (not that is matters as TTM
- * allocates one page at a time.
- */
-static int ttm_dma_pool_get_pages(struct dma_pool *pool,
-                                 struct ttm_dma_tt *ttm_dma,
-                                 unsigned index)
-{
-       struct dma_page *d_page;
-       struct ttm_tt *ttm = &ttm_dma->ttm;
-       unsigned long irq_flags;
-       int count, r = -ENOMEM;
-
-       spin_lock_irqsave(&pool->lock, irq_flags);
-       count = ttm_dma_page_pool_fill_locked(pool, &irq_flags);
-       if (count) {
-               d_page = list_first_entry(&pool->free_list, struct dma_page, page_list);
-               ttm->pages[index] = d_page->p;
-               ttm_dma->dma_address[index] = d_page->dma;
-               list_move_tail(&d_page->page_list, &ttm_dma->pages_list);
-               r = 0;
-               pool->npages_in_use += 1;
-               pool->npages_free -= 1;
-       }
-       spin_unlock_irqrestore(&pool->lock, irq_flags);
-       return r;
-}
-
-/*
- * On success pages list will hold count number of correctly
- * cached pages. On failure will hold the negative return value (-ENOMEM, etc).
- */
-int ttm_dma_populate(struct ttm_dma_tt *ttm_dma, struct device *dev)
-{
-       struct ttm_tt *ttm = &ttm_dma->ttm;
-       struct ttm_mem_global *mem_glob = ttm->glob->mem_glob;
-       struct dma_pool *pool;
-       enum pool_type type;
-       unsigned i;
-       gfp_t gfp_flags;
-       int ret;
-
-       if (ttm->state != tt_unpopulated)
-               return 0;
-
-       type = ttm_to_type(ttm->page_flags, ttm->caching_state);
-       if (ttm->page_flags & TTM_PAGE_FLAG_DMA32)
-               gfp_flags = GFP_USER | GFP_DMA32;
-       else
-               gfp_flags = GFP_HIGHUSER;
-       if (ttm->page_flags & TTM_PAGE_FLAG_ZERO_ALLOC)
-               gfp_flags |= __GFP_ZERO;
-
-       pool = ttm_dma_find_pool(dev, type);
-       if (!pool) {
-               pool = ttm_dma_pool_init(dev, gfp_flags, type);
-               if (IS_ERR_OR_NULL(pool)) {
-                       return -ENOMEM;
-               }
-       }
-
-       INIT_LIST_HEAD(&ttm_dma->pages_list);
-       for (i = 0; i < ttm->num_pages; ++i) {
-               ret = ttm_dma_pool_get_pages(pool, ttm_dma, i);
-               if (ret != 0) {
-                       ttm_dma_unpopulate(ttm_dma, dev);
-                       return -ENOMEM;
-               }
-
-               ret = ttm_mem_global_alloc_page(mem_glob, ttm->pages[i],
-                                               false, false);
-               if (unlikely(ret != 0)) {
-                       ttm_dma_unpopulate(ttm_dma, dev);
-                       return -ENOMEM;
-               }
-       }
-
-       if (unlikely(ttm->page_flags & TTM_PAGE_FLAG_SWAPPED)) {
-               ret = ttm_tt_swapin(ttm);
-               if (unlikely(ret != 0)) {
-                       ttm_dma_unpopulate(ttm_dma, dev);
-                       return ret;
-               }
-       }
-
-       ttm->state = tt_unbound;
-       return 0;
-}
-EXPORT_SYMBOL_GPL(ttm_dma_populate);
-
-/* Get good estimation how many pages are free in pools */
-static int ttm_dma_pool_get_num_unused_pages(void)
-{
-       struct device_pools *p;
-       unsigned total = 0;
-
-       mutex_lock(&_manager->lock);
-       list_for_each_entry(p, &_manager->pools, pools)
-               total += p->pool->npages_free;
-       mutex_unlock(&_manager->lock);
-       return total;
-}
-
-/* Put all pages in pages list to correct pool to wait for reuse */
-void ttm_dma_unpopulate(struct ttm_dma_tt *ttm_dma, struct device *dev)
-{
-       struct ttm_tt *ttm = &ttm_dma->ttm;
-       struct dma_pool *pool;
-       struct dma_page *d_page, *next;
-       enum pool_type type;
-       bool is_cached = false;
-       unsigned count = 0, i, npages = 0;
-       unsigned long irq_flags;
-
-       type = ttm_to_type(ttm->page_flags, ttm->caching_state);
-       pool = ttm_dma_find_pool(dev, type);
-       if (!pool)
-               return;
-
-       is_cached = (ttm_dma_find_pool(pool->dev,
-                    ttm_to_type(ttm->page_flags, tt_cached)) == pool);
-
-       /* make sure pages array match list and count number of pages */
-       list_for_each_entry(d_page, &ttm_dma->pages_list, page_list) {
-               ttm->pages[count] = d_page->p;
-               count++;
-       }
-
-       spin_lock_irqsave(&pool->lock, irq_flags);
-       pool->npages_in_use -= count;
-       if (is_cached) {
-               pool->nfrees += count;
-       } else {
-               pool->npages_free += count;
-               list_splice(&ttm_dma->pages_list, &pool->free_list);
-               npages = count;
-               if (pool->npages_free > _manager->options.max_size) {
-                       npages = pool->npages_free - _manager->options.max_size;
-                       /* free at least NUM_PAGES_TO_ALLOC number of pages
-                        * to reduce calls to set_memory_wb */
-                       if (npages < NUM_PAGES_TO_ALLOC)
-                               npages = NUM_PAGES_TO_ALLOC;
-               }
-       }
-       spin_unlock_irqrestore(&pool->lock, irq_flags);
-
-       if (is_cached) {
-               list_for_each_entry_safe(d_page, next, &ttm_dma->pages_list, page_list) {
-                       ttm_mem_global_free_page(ttm->glob->mem_glob,
-                                                d_page->p);
-                       ttm_dma_page_put(pool, d_page);
-               }
-       } else {
-               for (i = 0; i < count; i++) {
-                       ttm_mem_global_free_page(ttm->glob->mem_glob,
-                                                ttm->pages[i]);
-               }
-       }
-
-       INIT_LIST_HEAD(&ttm_dma->pages_list);
-       for (i = 0; i < ttm->num_pages; i++) {
-               ttm->pages[i] = NULL;
-               ttm_dma->dma_address[i] = 0;
-       }
-
-       /* shrink pool if necessary (only on !is_cached pools)*/
-       if (npages)
-               ttm_dma_page_pool_free(pool, npages);
-       ttm->state = tt_unpopulated;
-}
-EXPORT_SYMBOL_GPL(ttm_dma_unpopulate);
-
-/**
- * Callback for mm to request pool to reduce number of page held.
- */
-static int ttm_dma_pool_mm_shrink(struct shrinker *shrink,
-                                 struct shrink_control *sc)
-{
-       static atomic_t start_pool = ATOMIC_INIT(0);
-       unsigned idx = 0;
-       unsigned pool_offset = atomic_add_return(1, &start_pool);
-       unsigned shrink_pages = sc->nr_to_scan;
-       struct device_pools *p;
-
-       if (list_empty(&_manager->pools))
-               return 0;
-
-       mutex_lock(&_manager->lock);
-       pool_offset = pool_offset % _manager->npools;
-       list_for_each_entry(p, &_manager->pools, pools) {
-               unsigned nr_free;
-
-               if (!p->dev)
-                       continue;
-               if (shrink_pages == 0)
-                       break;
-               /* Do it in round-robin fashion. */
-               if (++idx < pool_offset)
-                       continue;
-               nr_free = shrink_pages;
-               shrink_pages = ttm_dma_page_pool_free(p->pool, nr_free);
-               pr_debug("%s: (%s:%d) Asked to shrink %d, have %d more to go\n",
-                        p->pool->dev_name, p->pool->name, current->pid,
-                        nr_free, shrink_pages);
-       }
-       mutex_unlock(&_manager->lock);
-       /* return estimated number of unused pages in pool */
-       return ttm_dma_pool_get_num_unused_pages();
-}
-
-static void ttm_dma_pool_mm_shrink_init(struct ttm_pool_manager *manager)
-{
-       manager->mm_shrink.shrink = &ttm_dma_pool_mm_shrink;
-       manager->mm_shrink.seeks = 1;
-       register_shrinker(&manager->mm_shrink);
-}
-
-static void ttm_dma_pool_mm_shrink_fini(struct ttm_pool_manager *manager)
-{
-       unregister_shrinker(&manager->mm_shrink);
-}
-
-int ttm_dma_page_alloc_init(struct ttm_mem_global *glob, unsigned max_pages)
-{
-       int ret = -ENOMEM;
-
-       WARN_ON(_manager);
-
-       pr_info("Initializing DMA pool allocator\n");
-
-       _manager = kzalloc(sizeof(*_manager), GFP_KERNEL);
-       if (!_manager)
-               goto err;
-
-       mutex_init(&_manager->lock);
-       INIT_LIST_HEAD(&_manager->pools);
-
-       _manager->options.max_size = max_pages;
-       _manager->options.small = SMALL_ALLOCATION;
-       _manager->options.alloc_size = NUM_PAGES_TO_ALLOC;
-
-       /* This takes care of auto-freeing the _manager */
-       ret = kobject_init_and_add(&_manager->kobj, &ttm_pool_kobj_type,
-                                  &glob->kobj, "dma_pool");
-       if (unlikely(ret != 0)) {
-               kobject_put(&_manager->kobj);
-               goto err;
-       }
-       ttm_dma_pool_mm_shrink_init(_manager);
-       return 0;
-err:
-       return ret;
-}
-
-void ttm_dma_page_alloc_fini(void)
-{
-       struct device_pools *p, *t;
-
-       pr_info("Finalizing DMA pool allocator\n");
-       ttm_dma_pool_mm_shrink_fini(_manager);
-
-       list_for_each_entry_safe_reverse(p, t, &_manager->pools, pools) {
-               dev_dbg(p->dev, "(%s:%d) Freeing.\n", p->pool->name,
-                       current->pid);
-               WARN_ON(devres_destroy(p->dev, ttm_dma_pool_release,
-                       ttm_dma_pool_match, p->pool));
-               ttm_dma_free_pool(p->dev, p->pool->type);
-       }
-       kobject_put(&_manager->kobj);
-       _manager = NULL;
-}
-
-int ttm_dma_page_alloc_debugfs(struct seq_file *m, void *data)
-{
-       struct device_pools *p;
-       struct dma_pool *pool = NULL;
-       char *h[] = {"pool", "refills", "pages freed", "inuse", "available",
-                    "name", "virt", "busaddr"};
-
-       if (!_manager) {
-               seq_printf(m, "No pool allocator running.\n");
-               return 0;
-       }
-       seq_printf(m, "%13s %12s %13s %8s %8s %8s\n",
-                  h[0], h[1], h[2], h[3], h[4], h[5]);
-       mutex_lock(&_manager->lock);
-       list_for_each_entry(p, &_manager->pools, pools) {
-               struct device *dev = p->dev;
-               if (!dev)
-                       continue;
-               pool = p->pool;
-               seq_printf(m, "%13s %12ld %13ld %8d %8d %8s\n",
-                               pool->name, pool->nrefills,
-                               pool->nfrees, pool->npages_in_use,
-                               pool->npages_free,
-                               pool->dev_name);
-       }
-       mutex_unlock(&_manager->lock);
-       return 0;
-}
-EXPORT_SYMBOL_GPL(ttm_dma_page_alloc_debugfs);
index 2c9301a..57032e9 100644 (file)
@@ -38,6 +38,8 @@
  */
 
 #include <drm/drmP.h>
+
+#include <linux/export.h>
 #include <drm/ttm/ttm_module.h>
 #include <drm/ttm/ttm_bo_driver.h>
 #include <drm/ttm/ttm_placement.h>
@@ -62,7 +64,6 @@ static void ttm_dma_tt_alloc_page_directory(struct ttm_dma_tt *ttm)
            sizeof(*ttm->dma_address), M_TTM_PD, M_WAITOK);
 }
 
-#if defined(__i386__) || defined(__amd64__)
 static inline int ttm_tt_set_page_caching(vm_page_t p,
                                          enum ttm_caching_state c_old,
                                          enum ttm_caching_state c_new)
@@ -84,14 +85,6 @@ static inline int ttm_tt_set_page_caching(vm_page_t p,
 
        return (0);
 }
-#else
-static inline int ttm_tt_set_page_caching(vm_page_t p,
-                                         enum ttm_caching_state c_old,
-                                         enum ttm_caching_state c_new)
-{
-       return 0;
-}
-#endif
 
 /*
  * Change caching policy for the linear kernel map
@@ -135,7 +128,7 @@ static int ttm_tt_set_caching(struct ttm_tt *ttm,
 out_err:
        for (j = 0; j < i; ++j) {
                cur_page = ttm->pages[j];
-               if (cur_page != NULL) {
+               if (likely(cur_page != NULL)) {
                        (void)ttm_tt_set_page_caching(cur_page, c_state,
                                                      ttm->caching_state);
                }
@@ -157,6 +150,7 @@ int ttm_tt_set_placement_caching(struct ttm_tt *ttm, uint32_t placement)
 
        return ttm_tt_set_caching(ttm, state);
 }
+EXPORT_SYMBOL(ttm_tt_set_placement_caching);
 
 void ttm_tt_destroy(struct ttm_tt *ttm)
 {
@@ -200,12 +194,14 @@ int ttm_tt_init(struct ttm_tt *ttm, struct ttm_bo_device *bdev,
        }
        return 0;
 }
+EXPORT_SYMBOL(ttm_tt_init);
 
 void ttm_tt_fini(struct ttm_tt *ttm)
 {
        drm_free(ttm->pages, M_TTM_PD);
        ttm->pages = NULL;
 }
+EXPORT_SYMBOL(ttm_tt_fini);
 
 int ttm_dma_tt_init(struct ttm_dma_tt *ttm_dma, struct ttm_bo_device *bdev,
                unsigned long size, uint32_t page_flags,
@@ -231,6 +227,7 @@ int ttm_dma_tt_init(struct ttm_dma_tt *ttm_dma, struct ttm_bo_device *bdev,
        }
        return 0;
 }
+EXPORT_SYMBOL(ttm_dma_tt_init);
 
 void ttm_dma_tt_fini(struct ttm_dma_tt *ttm_dma)
 {
@@ -241,6 +238,7 @@ void ttm_dma_tt_fini(struct ttm_dma_tt *ttm_dma)
        drm_free(ttm_dma->dma_address, M_TTM_PD);
        ttm_dma->dma_address = NULL;
 }
+EXPORT_SYMBOL(ttm_dma_tt_fini);
 
 void ttm_tt_unbind(struct ttm_tt *ttm)
 {
@@ -248,7 +246,7 @@ void ttm_tt_unbind(struct ttm_tt *ttm)
 
        if (ttm->state == tt_bound) {
                ret = ttm->func->unbind(ttm);
-               KKASSERT(ret == 0);
+               BUG_ON(ret);
                ttm->state = tt_unbound;
        }
 }
@@ -275,6 +273,7 @@ int ttm_tt_bind(struct ttm_tt *ttm, struct ttm_mem_reg *bo_mem)
 
        return 0;
 }
+EXPORT_SYMBOL(ttm_tt_bind);
 
 int ttm_tt_swapin(struct ttm_tt *ttm)
 {
@@ -330,18 +329,12 @@ int ttm_tt_swapout(struct ttm_tt *ttm, vm_object_t persistent_swap_storage)
        vm_page_t from_page, to_page;
        int i;
 
-       KKASSERT(ttm->state == tt_unbound || ttm->state == tt_unpopulated);
-       KKASSERT(ttm->caching_state == tt_cached);
+       BUG_ON(ttm->state != tt_unbound && ttm->state != tt_unpopulated);
+       BUG_ON(ttm->caching_state != tt_cached);
 
-       if (persistent_swap_storage == NULL) {
-#if 0
-               obj = vm_pager_allocate(OBJT_SWAP, NULL,
-                   IDX_TO_OFF(ttm->num_pages), VM_PROT_DEFAULT, 0,
-                   curthread->td_ucred);
-#else
+       if (!persistent_swap_storage) {
                obj = swap_pager_alloc(NULL,
                    IDX_TO_OFF(ttm->num_pages), VM_PROT_DEFAULT, 0);
-#endif
                if (obj == NULL) {
                        kprintf("[TTM] Failed allocating swap storage\n");
                        return (-ENOMEM);
@@ -368,7 +361,8 @@ int ttm_tt_swapout(struct ttm_tt *ttm, vm_object_t persistent_swap_storage)
        ttm->bdev->driver->ttm_tt_unpopulate(ttm);
        ttm->swap_storage = obj;
        ttm->page_flags |= TTM_PAGE_FLAG_SWAPPED;
-       if (persistent_swap_storage != NULL)
+       if (persistent_swap_storage)
                ttm->page_flags |= TTM_PAGE_FLAG_PERSISTENT_SWAP;
-       return (0);
+
+       return 0;
 }