Merge branch 'drm-fixes-4.3' of git://people.freedesktop.org/~agd5f/linux into drm-fixes (e4b35f95) · Commits · e / devices / android_kernel_xiaomi_nabu

drivers/gpu/drm/amd/amdgpu/amdgpu.h

+6 −5

Original line number	Original line	Diff line number	Diff line
	@@ -82,6 +82,7 @@ extern int amdgpu_vm_block_size;
	extern int amdgpu_enable_scheduler;		extern int amdgpu_enable_scheduler;
	extern int amdgpu_sched_jobs;		extern int amdgpu_sched_jobs;
	extern int amdgpu_sched_hw_submission;		extern int amdgpu_sched_hw_submission;
			extern int amdgpu_enable_semaphores;

	#define AMDGPU_WAIT_IDLE_TIMEOUT_IN_MS 3000		#define AMDGPU_WAIT_IDLE_TIMEOUT_IN_MS 3000
	#define AMDGPU_MAX_USEC_TIMEOUT 100000 /* 100 ms */		#define AMDGPU_MAX_USEC_TIMEOUT 100000 /* 100 ms */
	@@ -432,7 +433,7 @@ int amdgpu_fence_driver_init(struct amdgpu_device *adev);
	void amdgpu_fence_driver_fini(struct amdgpu_device *adev);		void amdgpu_fence_driver_fini(struct amdgpu_device *adev);
	void amdgpu_fence_driver_force_completion(struct amdgpu_device *adev);		void amdgpu_fence_driver_force_completion(struct amdgpu_device *adev);

	void amdgpu_fence_driver_init_ring(struct amdgpu_ring *ring);		int amdgpu_fence_driver_init_ring(struct amdgpu_ring *ring);
	int amdgpu_fence_driver_start_ring(struct amdgpu_ring *ring,		int amdgpu_fence_driver_start_ring(struct amdgpu_ring *ring,
	struct amdgpu_irq_src *irq_src,		struct amdgpu_irq_src *irq_src,
	unsigned irq_type);		unsigned irq_type);
	@@ -890,7 +891,7 @@ struct amdgpu_ring {
	struct amdgpu_device *adev;		struct amdgpu_device *adev;
	const struct amdgpu_ring_funcs *funcs;		const struct amdgpu_ring_funcs *funcs;
	struct amdgpu_fence_driver fence_drv;		struct amdgpu_fence_driver fence_drv;
	struct amd_gpu_scheduler *scheduler;		struct amd_gpu_scheduler sched;

	spinlock_t fence_lock;		spinlock_t fence_lock;
	struct mutex *ring_lock;		struct mutex *ring_lock;
	@@ -1201,8 +1202,6 @@ struct amdgpu_gfx {
	struct amdgpu_irq_src priv_inst_irq;		struct amdgpu_irq_src priv_inst_irq;
	/* gfx status */		/* gfx status */
	uint32_t gfx_current_status;		uint32_t gfx_current_status;
	/* sync signal for const engine */
	unsigned ce_sync_offs;
	/* ce ram size*/		/* ce ram size*/
	unsigned ce_ram_size;		unsigned ce_ram_size;
	};		};
	@@ -1274,8 +1273,10 @@ struct amdgpu_job {
	uint32_t num_ibs;		uint32_t num_ibs;
	struct mutex job_lock;		struct mutex job_lock;
	struct amdgpu_user_fence uf;		struct amdgpu_user_fence uf;
	int (free_job)(struct amdgpu_job sched_job);		int (free_job)(struct amdgpu_job job);
	};		};
			#define to_amdgpu_job(sched_job) \
			container_of((sched_job), struct amdgpu_job, base)

	static inline u32 amdgpu_get_ib_value(struct amdgpu_cs_parser *p, uint32_t ib_idx, int idx)		static inline u32 amdgpu_get_ib_value(struct amdgpu_cs_parser *p, uint32_t ib_idx, int idx)
	{		{

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -183,7 +183,7 @@ int alloc_gtt_mem(struct kgd_dev *kgd, size_t size,
	return -ENOMEM;		return -ENOMEM;

	r = amdgpu_bo_create(rdev, size, PAGE_SIZE, true, AMDGPU_GEM_DOMAIN_GTT,		r = amdgpu_bo_create(rdev, size, PAGE_SIZE, true, AMDGPU_GEM_DOMAIN_GTT,
	AMDGPU_GEM_CREATE_CPU_GTT_USWC, NULL, &(*mem)->bo);		AMDGPU_GEM_CREATE_CPU_GTT_USWC, NULL, NULL, &(*mem)->bo);
	if (r) {		if (r) {
	dev_err(rdev->dev,		dev_err(rdev->dev,
	"failed to allocate BO for amdkfd (%d)\n", r);		"failed to allocate BO for amdkfd (%d)\n", r);

drivers/gpu/drm/amd/amdgpu/amdgpu_benchmark.c

+4 −2

Original line number	Original line	Diff line number	Diff line
	@@ -79,7 +79,8 @@ static void amdgpu_benchmark_move(struct amdgpu_device *adev, unsigned size,
	int time;		int time;

	n = AMDGPU_BENCHMARK_ITERATIONS;		n = AMDGPU_BENCHMARK_ITERATIONS;
	r = amdgpu_bo_create(adev, size, PAGE_SIZE, true, sdomain, 0, NULL, &sobj);		r = amdgpu_bo_create(adev, size, PAGE_SIZE, true, sdomain, 0, NULL,
			NULL, &sobj);
	if (r) {		if (r) {
	goto out_cleanup;		goto out_cleanup;
	}		}
	@@ -91,7 +92,8 @@ static void amdgpu_benchmark_move(struct amdgpu_device *adev, unsigned size,
	if (r) {		if (r) {
	goto out_cleanup;		goto out_cleanup;
	}		}
	r = amdgpu_bo_create(adev, size, PAGE_SIZE, true, ddomain, 0, NULL, &dobj);		r = amdgpu_bo_create(adev, size, PAGE_SIZE, true, ddomain, 0, NULL,
			NULL, &dobj);
	if (r) {		if (r) {
	goto out_cleanup;		goto out_cleanup;
	}		}

drivers/gpu/drm/amd/amdgpu/amdgpu_cgs.c

+3 −2

Original line number	Original line	Diff line number	Diff line
	@@ -86,7 +86,7 @@ static int amdgpu_cgs_gmap_kmem(void cgs_device, void kmem,

	struct sg_table *sg = drm_prime_pages_to_sg(&kmem_page, npages);		struct sg_table *sg = drm_prime_pages_to_sg(&kmem_page, npages);
	ret = amdgpu_bo_create(adev, size, PAGE_SIZE, false,		ret = amdgpu_bo_create(adev, size, PAGE_SIZE, false,
	AMDGPU_GEM_DOMAIN_GTT, 0, sg, &bo);		AMDGPU_GEM_DOMAIN_GTT, 0, sg, NULL, &bo);
	if (ret)		if (ret)
	return ret;		return ret;
	ret = amdgpu_bo_reserve(bo, false);		ret = amdgpu_bo_reserve(bo, false);
	@@ -197,7 +197,8 @@ static int amdgpu_cgs_alloc_gpu_mem(void *cgs_device,

	ret = amdgpu_bo_create_restricted(adev, size, PAGE_SIZE,		ret = amdgpu_bo_create_restricted(adev, size, PAGE_SIZE,
	true, domain, flags,		true, domain, flags,
	NULL, &placement, &obj);		NULL, &placement, NULL,
			&obj);
	if (ret) {		if (ret) {
	DRM_ERROR("(%d) bo create failed\n", ret);		DRM_ERROR("(%d) bo create failed\n", ret);
	return ret;		return ret;

drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c

+80 −57

Original line number	Original line	Diff line number	Diff line
	@@ -154,42 +154,41 @@ int amdgpu_cs_parser_init(struct amdgpu_cs_parser p, void data)
	{		{
	union drm_amdgpu_cs *cs = data;		union drm_amdgpu_cs *cs = data;
	uint64_t *chunk_array_user;		uint64_t *chunk_array_user;
	uint64_t *chunk_array = NULL;		uint64_t *chunk_array;
	struct amdgpu_fpriv *fpriv = p->filp->driver_priv;		struct amdgpu_fpriv *fpriv = p->filp->driver_priv;
	unsigned size, i;		unsigned size, i;
	int r = 0;		int ret;

	if (!cs->in.num_chunks)		if (cs->in.num_chunks == 0)
	goto out;		return 0;

			chunk_array = kmalloc_array(cs->in.num_chunks, sizeof(uint64_t), GFP_KERNEL);
			if (!chunk_array)
			return -ENOMEM;

	p->ctx = amdgpu_ctx_get(fpriv, cs->in.ctx_id);		p->ctx = amdgpu_ctx_get(fpriv, cs->in.ctx_id);
	if (!p->ctx) {		if (!p->ctx) {
	r = -EINVAL;		ret = -EINVAL;
	goto out;		goto free_chunk;
	}		}

	p->bo_list = amdgpu_bo_list_get(fpriv, cs->in.bo_list_handle);		p->bo_list = amdgpu_bo_list_get(fpriv, cs->in.bo_list_handle);

	/* get chunks */		/* get chunks */
	INIT_LIST_HEAD(&p->validated);		INIT_LIST_HEAD(&p->validated);
	chunk_array = kmalloc_array(cs->in.num_chunks, sizeof(uint64_t), GFP_KERNEL);
	if (chunk_array == NULL) {
	r = -ENOMEM;
	goto out;
	}

	chunk_array_user = (uint64_t __user *)(cs->in.chunks);		chunk_array_user = (uint64_t __user *)(cs->in.chunks);
	if (copy_from_user(chunk_array, chunk_array_user,		if (copy_from_user(chunk_array, chunk_array_user,
	sizeof(uint64_t)*cs->in.num_chunks)) {		sizeof(uint64_t)*cs->in.num_chunks)) {
	r = -EFAULT;		ret = -EFAULT;
	goto out;		goto put_bo_list;
	}		}

	p->nchunks = cs->in.num_chunks;		p->nchunks = cs->in.num_chunks;
	p->chunks = kmalloc_array(p->nchunks, sizeof(struct amdgpu_cs_chunk),		p->chunks = kmalloc_array(p->nchunks, sizeof(struct amdgpu_cs_chunk),
	GFP_KERNEL);		GFP_KERNEL);
	if (p->chunks == NULL) {		if (!p->chunks) {
	r = -ENOMEM;		ret = -ENOMEM;
	goto out;		goto put_bo_list;
	}		}

	for (i = 0; i < p->nchunks; i++) {		for (i = 0; i < p->nchunks; i++) {
	@@ -200,8 +199,9 @@ int amdgpu_cs_parser_init(struct amdgpu_cs_parser p, void data)
	chunk_ptr = (void __user *)chunk_array[i];		chunk_ptr = (void __user *)chunk_array[i];
	if (copy_from_user(&user_chunk, chunk_ptr,		if (copy_from_user(&user_chunk, chunk_ptr,
	sizeof(struct drm_amdgpu_cs_chunk))) {		sizeof(struct drm_amdgpu_cs_chunk))) {
	r = -EFAULT;		ret = -EFAULT;
	goto out;		i--;
			goto free_partial_kdata;
	}		}
	p->chunks[i].chunk_id = user_chunk.chunk_id;		p->chunks[i].chunk_id = user_chunk.chunk_id;
	p->chunks[i].length_dw = user_chunk.length_dw;		p->chunks[i].length_dw = user_chunk.length_dw;
	@@ -212,13 +212,14 @@ int amdgpu_cs_parser_init(struct amdgpu_cs_parser p, void data)

	p->chunks[i].kdata = drm_malloc_ab(size, sizeof(uint32_t));		p->chunks[i].kdata = drm_malloc_ab(size, sizeof(uint32_t));
	if (p->chunks[i].kdata == NULL) {		if (p->chunks[i].kdata == NULL) {
	r = -ENOMEM;		ret = -ENOMEM;
	goto out;		i--;
			goto free_partial_kdata;
	}		}
	size *= sizeof(uint32_t);		size *= sizeof(uint32_t);
	if (copy_from_user(p->chunks[i].kdata, cdata, size)) {		if (copy_from_user(p->chunks[i].kdata, cdata, size)) {
	r = -EFAULT;		ret = -EFAULT;
	goto out;		goto free_partial_kdata;
	}		}

	switch (p->chunks[i].chunk_id) {		switch (p->chunks[i].chunk_id) {
	@@ -238,15 +239,15 @@ int amdgpu_cs_parser_init(struct amdgpu_cs_parser p, void data)
	gobj = drm_gem_object_lookup(p->adev->ddev,		gobj = drm_gem_object_lookup(p->adev->ddev,
	p->filp, handle);		p->filp, handle);
	if (gobj == NULL) {		if (gobj == NULL) {
	r = -EINVAL;		ret = -EINVAL;
	goto out;		goto free_partial_kdata;
	}		}

	p->uf.bo = gem_to_amdgpu_bo(gobj);		p->uf.bo = gem_to_amdgpu_bo(gobj);
	p->uf.offset = fence_data->offset;		p->uf.offset = fence_data->offset;
	} else {		} else {
	r = -EINVAL;		ret = -EINVAL;
	goto out;		goto free_partial_kdata;
	}		}
	break;		break;

	@@ -254,19 +255,35 @@ int amdgpu_cs_parser_init(struct amdgpu_cs_parser p, void data)
	break;		break;

	default:		default:
	r = -EINVAL;		ret = -EINVAL;
	goto out;		goto free_partial_kdata;
	}		}
	}		}


	p->ibs = kcalloc(p->num_ibs, sizeof(struct amdgpu_ib), GFP_KERNEL);		p->ibs = kcalloc(p->num_ibs, sizeof(struct amdgpu_ib), GFP_KERNEL);
	if (!p->ibs)		if (!p->ibs) {
	r = -ENOMEM;		ret = -ENOMEM;
			goto free_all_kdata;
			}

	out:
	kfree(chunk_array);		kfree(chunk_array);
	return r;		return 0;

			free_all_kdata:
			i = p->nchunks - 1;
			free_partial_kdata:
			for (; i >= 0; i--)
			drm_free_large(p->chunks[i].kdata);
			kfree(p->chunks);
			put_bo_list:
			if (p->bo_list)
			amdgpu_bo_list_put(p->bo_list);
			amdgpu_ctx_put(p->ctx);
			free_chunk:
			kfree(chunk_array);

			return ret;
	}		}

	/* Returns how many bytes TTM can move per IB.		/* Returns how many bytes TTM can move per IB.
	@@ -321,25 +338,17 @@ static u64 amdgpu_cs_get_threshold_for_moves(struct amdgpu_device *adev)
	return max(bytes_moved_threshold, 1024*1024ull);		return max(bytes_moved_threshold, 1024*1024ull);
	}		}

	int amdgpu_cs_list_validate(struct amdgpu_cs_parser *p)		int amdgpu_cs_list_validate(struct amdgpu_device *adev,
			struct amdgpu_vm *vm,
			struct list_head *validated)
	{		{
	struct amdgpu_fpriv *fpriv = p->filp->driver_priv;
	struct amdgpu_vm *vm = &fpriv->vm;
	struct amdgpu_device *adev = p->adev;
	struct amdgpu_bo_list_entry *lobj;		struct amdgpu_bo_list_entry *lobj;
	struct list_head duplicates;
	struct amdgpu_bo *bo;		struct amdgpu_bo *bo;
	u64 bytes_moved = 0, initial_bytes_moved;		u64 bytes_moved = 0, initial_bytes_moved;
	u64 bytes_moved_threshold = amdgpu_cs_get_threshold_for_moves(adev);		u64 bytes_moved_threshold = amdgpu_cs_get_threshold_for_moves(adev);
	int r;		int r;

	INIT_LIST_HEAD(&duplicates);		list_for_each_entry(lobj, validated, tv.head) {
	r = ttm_eu_reserve_buffers(&p->ticket, &p->validated, true, &duplicates);
	if (unlikely(r != 0)) {
	return r;
	}

	list_for_each_entry(lobj, &p->validated, tv.head) {
	bo = lobj->robj;		bo = lobj->robj;
	if (!bo->pin_count) {		if (!bo->pin_count) {
	u32 domain = lobj->prefered_domains;		u32 domain = lobj->prefered_domains;
	@@ -373,7 +382,6 @@ int amdgpu_cs_list_validate(struct amdgpu_cs_parser *p)
	domain = lobj->allowed_domains;		domain = lobj->allowed_domains;
	goto retry;		goto retry;
	}		}
	ttm_eu_backoff_reservation(&p->ticket, &p->validated);
	return r;		return r;
	}		}
	}		}
	@@ -386,6 +394,7 @@ static int amdgpu_cs_parser_relocs(struct amdgpu_cs_parser *p)
	{		{
	struct amdgpu_fpriv *fpriv = p->filp->driver_priv;		struct amdgpu_fpriv *fpriv = p->filp->driver_priv;
	struct amdgpu_cs_buckets buckets;		struct amdgpu_cs_buckets buckets;
			struct list_head duplicates;
	bool need_mmap_lock = false;		bool need_mmap_lock = false;
	int i, r;		int i, r;

	@@ -405,8 +414,22 @@ static int amdgpu_cs_parser_relocs(struct amdgpu_cs_parser *p)
	if (need_mmap_lock)		if (need_mmap_lock)
	down_read(&current->mm->mmap_sem);		down_read(&current->mm->mmap_sem);

	r = amdgpu_cs_list_validate(p);		INIT_LIST_HEAD(&duplicates);
			r = ttm_eu_reserve_buffers(&p->ticket, &p->validated, true, &duplicates);
			if (unlikely(r != 0))
			goto error_reserve;

			r = amdgpu_cs_list_validate(p->adev, &fpriv->vm, &p->validated);
			if (r)
			goto error_validate;

			r = amdgpu_cs_list_validate(p->adev, &fpriv->vm, &duplicates);

			error_validate:
			if (r)
			ttm_eu_backoff_reservation(&p->ticket, &p->validated);

			error_reserve:
	if (need_mmap_lock)		if (need_mmap_lock)
	up_read(&current->mm->mmap_sem);		up_read(&current->mm->mmap_sem);

	@@ -772,15 +795,15 @@ static int amdgpu_cs_dependencies(struct amdgpu_device *adev,
	return 0;		return 0;
	}		}

	static int amdgpu_cs_free_job(struct amdgpu_job *sched_job)		static int amdgpu_cs_free_job(struct amdgpu_job *job)
	{		{
	int i;		int i;
	if (sched_job->ibs)		if (job->ibs)
	for (i = 0; i < sched_job->num_ibs; i++)		for (i = 0; i < job->num_ibs; i++)
	amdgpu_ib_free(sched_job->adev, &sched_job->ibs[i]);		amdgpu_ib_free(job->adev, &job->ibs[i]);
	kfree(sched_job->ibs);		kfree(job->ibs);
	if (sched_job->uf.bo)		if (job->uf.bo)
	drm_gem_object_unreference_unlocked(&sched_job->uf.bo->gem_base);		drm_gem_object_unreference_unlocked(&job->uf.bo->gem_base);
	return 0;		return 0;
	}		}

	@@ -804,7 +827,7 @@ int amdgpu_cs_ioctl(struct drm_device dev, void data, struct drm_file *filp)
	r = amdgpu_cs_parser_init(parser, data);		r = amdgpu_cs_parser_init(parser, data);
	if (r) {		if (r) {
	DRM_ERROR("Failed to initialize parser !\n");		DRM_ERROR("Failed to initialize parser !\n");
	amdgpu_cs_parser_fini(parser, r, false);		kfree(parser);
	up_read(&adev->exclusive_lock);		up_read(&adev->exclusive_lock);
	r = amdgpu_cs_handle_lockup(adev, r);		r = amdgpu_cs_handle_lockup(adev, r);
	return r;		return r;
	@@ -842,7 +865,7 @@ int amdgpu_cs_ioctl(struct drm_device dev, void data, struct drm_file *filp)
	job = kzalloc(sizeof(struct amdgpu_job), GFP_KERNEL);		job = kzalloc(sizeof(struct amdgpu_job), GFP_KERNEL);
	if (!job)		if (!job)
	return -ENOMEM;		return -ENOMEM;
	job->base.sched = ring->scheduler;		job->base.sched = &ring->sched;
	job->base.s_entity = &parser->ctx->rings[ring->idx].entity;		job->base.s_entity = &parser->ctx->rings[ring->idx].entity;
	job->adev = parser->adev;		job->adev = parser->adev;
	job->ibs = parser->ibs;		job->ibs = parser->ibs;
	@@ -857,7 +880,7 @@ int amdgpu_cs_ioctl(struct drm_device dev, void data, struct drm_file *filp)

	job->free_job = amdgpu_cs_free_job;		job->free_job = amdgpu_cs_free_job;
	mutex_lock(&job->job_lock);		mutex_lock(&job->job_lock);
	r = amd_sched_entity_push_job((struct amd_sched_job *)job);		r = amd_sched_entity_push_job(&job->base);
	if (r) {		if (r) {
	mutex_unlock(&job->job_lock);		mutex_unlock(&job->job_lock);
	amdgpu_cs_free_job(job);		amdgpu_cs_free_job(job);