drm/ttm: remove userspace backed ttm object support (3316497b) · Commits · e / devices / android_kernel_teracube_2e

drivers/gpu/drm/ttm/ttm_bo.c

+0 −22

Original line number	Diff line number	Diff line
		@@ -342,22 +342,6 @@ static int ttm_bo_add_ttm(struct ttm_buffer_object *bo, bool zero_alloc)
		if (unlikely(bo->ttm == NULL))
		ret = -ENOMEM;
		break;
		case ttm_bo_type_user:
		bo->ttm = ttm_tt_create(bdev, bo->num_pages << PAGE_SHIFT,
		page_flags \| TTM_PAGE_FLAG_USER,
		glob->dummy_read_page);
		if (unlikely(bo->ttm == NULL)) {
		ret = -ENOMEM;
		break;
		}

		ret = ttm_tt_set_user(bo->ttm, current,
		bo->buffer_start, bo->num_pages);
		if (unlikely(ret != 0)) {
		ttm_tt_destroy(bo->ttm);
		bo->ttm = NULL;
		}
		break;
		default:
		printk(KERN_ERR TTM_PFX "Illegal buffer object type\n");
		ret = -EINVAL;
		@@ -907,16 +891,12 @@ static uint32_t ttm_bo_select_caching(struct ttm_mem_type_manager *man,
		}

		static bool ttm_bo_mt_compatible(struct ttm_mem_type_manager *man,
		bool disallow_fixed,
		uint32_t mem_type,
		uint32_t proposed_placement,
		uint32_t *masked_placement)
		{
		uint32_t cur_flags = ttm_bo_type_flags(mem_type);

		if ((man->flags & TTM_MEMTYPE_FLAG_FIXED) && disallow_fixed)
		return false;

		if ((cur_flags & proposed_placement & TTM_PL_MASK_MEM) == 0)
		return false;

		@@ -961,7 +941,6 @@ int ttm_bo_mem_space(struct ttm_buffer_object *bo,
		man = &bdev->man[mem_type];

		type_ok = ttm_bo_mt_compatible(man,
		bo->type == ttm_bo_type_user,
		mem_type,
		placement->placement[i],
		&cur_flags);
		@@ -1009,7 +988,6 @@ int ttm_bo_mem_space(struct ttm_buffer_object *bo,
		if (!man->has_type)
		continue;
		if (!ttm_bo_mt_compatible(man,
		bo->type == ttm_bo_type_user,
		mem_type,
		placement->busy_placement[i],
		&cur_flags))

drivers/gpu/drm/ttm/ttm_tt.c

+1 −104

Original line number	Diff line number	Diff line
		@@ -63,43 +63,6 @@ static void ttm_tt_free_page_directory(struct ttm_tt *ttm)
		ttm->dma_address = NULL;
		}

		static void ttm_tt_free_user_pages(struct ttm_tt *ttm)
		{
		int write;
		int dirty;
		struct page *page;
		int i;
		struct ttm_backend *be = ttm->be;

		BUG_ON(!(ttm->page_flags & TTM_PAGE_FLAG_USER));
		write = ((ttm->page_flags & TTM_PAGE_FLAG_WRITE) != 0);
		dirty = ((ttm->page_flags & TTM_PAGE_FLAG_USER_DIRTY) != 0);

		if (be)
		be->func->clear(be);

		for (i = 0; i < ttm->num_pages; ++i) {
		page = ttm->pages[i];
		if (page == NULL)
		continue;

		if (page == ttm->dummy_read_page) {
		BUG_ON(write);
		continue;
		}

		if (write && dirty && !PageReserved(page))
		set_page_dirty_lock(page);

		ttm->pages[i] = NULL;
		ttm_mem_global_free(ttm->glob->mem_glob, PAGE_SIZE);
		put_page(page);
		}
		ttm->state = tt_unpopulated;
		ttm->first_himem_page = ttm->num_pages;
		ttm->last_lomem_page = -1;
		}

		static struct page __ttm_tt_get_page(struct ttm_tt ttm, int index)
		{
		struct page *p;
		@@ -326,9 +289,6 @@ void ttm_tt_destroy(struct ttm_tt *ttm)
		}

		if (likely(ttm->pages != NULL)) {
		if (ttm->page_flags & TTM_PAGE_FLAG_USER)
		ttm_tt_free_user_pages(ttm);
		else
		ttm_tt_free_alloced_pages(ttm);

		ttm_tt_free_page_directory(ttm);
		@@ -341,45 +301,6 @@ void ttm_tt_destroy(struct ttm_tt *ttm)
		kfree(ttm);
		}

		int ttm_tt_set_user(struct ttm_tt *ttm,
		struct task_struct *tsk,
		unsigned long start, unsigned long num_pages)
		{
		struct mm_struct *mm = tsk->mm;
		int ret;
		int write = (ttm->page_flags & TTM_PAGE_FLAG_WRITE) != 0;
		struct ttm_mem_global *mem_glob = ttm->glob->mem_glob;

		BUG_ON(num_pages != ttm->num_pages);
		BUG_ON((ttm->page_flags & TTM_PAGE_FLAG_USER) == 0);

		/**
		* Account user pages as lowmem pages for now.
		*/

		ret = ttm_mem_global_alloc(mem_glob, num_pages * PAGE_SIZE,
		false, false);
		if (unlikely(ret != 0))
		return ret;

		down_read(&mm->mmap_sem);
		ret = get_user_pages(tsk, mm, start, num_pages,
		write, 0, ttm->pages, NULL);
		up_read(&mm->mmap_sem);

		if (ret != num_pages && write) {
		ttm_tt_free_user_pages(ttm);
		ttm_mem_global_free(mem_glob, num_pages * PAGE_SIZE);
		return -ENOMEM;
		}

		ttm->tsk = tsk;
		ttm->start = start;
		ttm->state = tt_unbound;

		return 0;
		}

		struct ttm_tt ttm_tt_create(struct ttm_bo_device bdev, unsigned long size,
		uint32_t page_flags, struct page *dummy_read_page)
		{
		@@ -453,8 +374,6 @@ int ttm_tt_bind(struct ttm_tt ttm, struct ttm_mem_reg bo_mem)

		ttm->state = tt_bound;

		if (ttm->page_flags & TTM_PAGE_FLAG_USER)
		ttm->page_flags \|= TTM_PAGE_FLAG_USER_DIRTY;
		return 0;
		}
		EXPORT_SYMBOL(ttm_tt_bind);
		@@ -470,16 +389,6 @@ static int ttm_tt_swapin(struct ttm_tt *ttm)
		int i;
		int ret = -ENOMEM;

		if (ttm->page_flags & TTM_PAGE_FLAG_USER) {
		ret = ttm_tt_set_user(ttm, ttm->tsk, ttm->start,
		ttm->num_pages);
		if (unlikely(ret != 0))
		return ret;

		ttm->page_flags &= ~TTM_PAGE_FLAG_SWAPPED;
		return 0;
		}

		swap_storage = ttm->swap_storage;
		BUG_ON(swap_storage == NULL);

		@@ -530,18 +439,6 @@ int ttm_tt_swapout(struct ttm_tt ttm, struct file persistent_swap_storage)
		BUG_ON(ttm->state != tt_unbound && ttm->state != tt_unpopulated);
		BUG_ON(ttm->caching_state != tt_cached);

		/*
		* For user buffers, just unpin the pages, as there should be
		* vma references.
		*/

		if (ttm->page_flags & TTM_PAGE_FLAG_USER) {
		ttm_tt_free_user_pages(ttm);
		ttm->page_flags \|= TTM_PAGE_FLAG_SWAPPED;
		ttm->swap_storage = NULL;
		return 0;
		}

		if (!persistent_swap_storage) {
		swap_storage = shmem_file_setup("ttm swap",
		ttm->num_pages << PAGE_SHIFT,

include/drm/ttm/ttm_bo_api.h

+0 −5

Original line number	Diff line number	Diff line
		@@ -122,17 +122,12 @@ struct ttm_mem_reg {
		* be mmapped by user space. Each of these bos occupy a slot in the
		* device address space, that can be used for normal vm operations.
		*
		* @ttm_bo_type_user: These are user-space memory areas that are made
		* available to the GPU by mapping the buffer pages into the GPU aperture
		* space. These buffers cannot be mmaped from the device address space.
		*
		* @ttm_bo_type_kernel: These buffers are like ttm_bo_type_device buffers,
		* but they cannot be accessed from user-space. For kernel-only use.
		*/

		enum ttm_bo_type {
		ttm_bo_type_device,
		ttm_bo_type_user,
		ttm_bo_type_kernel
		};

include/drm/ttm/ttm_bo_driver.h

+0 −24

Original line number	Diff line number	Diff line
		@@ -118,8 +118,6 @@ struct ttm_backend {
		struct ttm_backend_func *func;
		};

		#define TTM_PAGE_FLAG_USER (1 << 1)
		#define TTM_PAGE_FLAG_USER_DIRTY (1 << 2)
		#define TTM_PAGE_FLAG_WRITE (1 << 3)
		#define TTM_PAGE_FLAG_SWAPPED (1 << 4)
		#define TTM_PAGE_FLAG_PERSISTENT_SWAP (1 << 5)
		@@ -146,8 +144,6 @@ enum ttm_caching_state {
		* @num_pages: Number of pages in the page array.
		* @bdev: Pointer to the current struct ttm_bo_device.
		* @be: Pointer to the ttm backend.
		* @tsk: The task for user ttm.
		* @start: virtual address for user ttm.
		* @swap_storage: Pointer to shmem struct file for swap storage.
		* @caching_state: The current caching state of the pages.
		* @state: The current binding state of the pages.
		@@ -167,8 +163,6 @@ struct ttm_tt {
		unsigned long num_pages;
		struct ttm_bo_global *glob;
		struct ttm_backend *be;
		struct task_struct *tsk;
		unsigned long start;
		struct file *swap_storage;
		enum ttm_caching_state caching_state;
		enum {
		@@ -617,24 +611,6 @@ extern struct ttm_tt ttm_tt_create(struct ttm_bo_device bdev,
		uint32_t page_flags,
		struct page *dummy_read_page);

		/**
		* ttm_tt_set_user:
		*
		* @ttm: The struct ttm_tt to populate.
		* @tsk: A struct task_struct for which @start is a valid user-space address.
		* @start: A valid user-space address.
		* @num_pages: Size in pages of the user memory area.
		*
		* Populate a struct ttm_tt with a user-space memory area after first pinning
		* the pages backing it.
		* Returns:
		* !0: Error.
		*/

		extern int ttm_tt_set_user(struct ttm_tt *ttm,
		struct task_struct *tsk,
		unsigned long start, unsigned long num_pages);

		/**
		* ttm_ttm_bind:
		*