drm/amdgpu: remove ring lru handling

	if (ring->funcs->end_use)

		ring->funcs->end_use(ring);

	if (ring->funcs->type != AMDGPU_RING_TYPE_KIQ)

		amdgpu_ring_lru_touch(ring->adev, ring);

}

/**

	ring->max_dw = max_dw;

	ring->priority = DRM_SCHED_PRIORITY_NORMAL;

	mutex_init(&ring->priority_mutex);

	INIT_LIST_HEAD(&ring->lru_list);

	amdgpu_ring_lru_touch(adev, ring);

	for (i = 0; i < DRM_SCHED_PRIORITY_MAX; ++i)

		atomic_set(&ring->num_jobs[i], 0);

	ring->adev->rings[ring->idx] = NULL;

}

static void amdgpu_ring_lru_touch_locked(struct amdgpu_device *adev,

					 struct amdgpu_ring *ring)

{

	/* list_move_tail handles the case where ring isn't part of the list */

	list_move_tail(&ring->lru_list, &adev->ring_lru_list);

}

static bool amdgpu_ring_is_blacklisted(struct amdgpu_ring *ring,

				       int *blacklist, int num_blacklist)

{

	int i;

	for (i = 0; i < num_blacklist; i++) {

		if (ring->idx == blacklist[i])

			return true;

	}

	return false;

}

/**

 * amdgpu_ring_lru_get - get the least recently used ring for a HW IP block

 *

 * @adev: amdgpu_device pointer

 * @type: amdgpu_ring_type enum

 * @blacklist: blacklisted ring ids array

 * @num_blacklist: number of entries in @blacklist

 * @lru_pipe_order: find a ring from the least recently used pipe

 * @ring: output ring

 *

 * Retrieve the amdgpu_ring structure for the least recently used ring of

 * a specific IP block (all asics).

 * Returns 0 on success, error on failure.

 */

int amdgpu_ring_lru_get(struct amdgpu_device *adev, int type,

			int *blacklist,	int num_blacklist,

			bool lru_pipe_order, struct amdgpu_ring **ring)

{

	struct amdgpu_ring *entry;

	/* List is sorted in LRU order, find first entry corresponding

	 * to the desired HW IP */

	*ring = NULL;

	spin_lock(&adev->ring_lru_list_lock);

	list_for_each_entry(entry, &adev->ring_lru_list, lru_list) {

		if (entry->funcs->type != type)

			continue;

		if (amdgpu_ring_is_blacklisted(entry, blacklist, num_blacklist))

			continue;

		if (!*ring) {

			*ring = entry;

			/* We are done for ring LRU */

			if (!lru_pipe_order)

				break;

		}

		/* Move all rings on the same pipe to the end of the list */

		if (entry->pipe == (*ring)->pipe)

			amdgpu_ring_lru_touch_locked(adev, entry);

	}

	/* Move the ring we found to the end of the list */

	if (*ring)

		amdgpu_ring_lru_touch_locked(adev, *ring);

	spin_unlock(&adev->ring_lru_list_lock);

	if (!*ring) {

		DRM_ERROR("Ring LRU contains no entries for ring type:%d\n", type);

		return -EINVAL;

	}

	return 0;

}

/**

 * amdgpu_ring_lru_touch - mark a ring as recently being used

 *

 * @adev: amdgpu_device pointer

 * @ring: ring to touch

 *

 * Move @ring to the tail of the lru list

 */

void amdgpu_ring_lru_touch(struct amdgpu_device *adev, struct amdgpu_ring *ring)

{

	spin_lock(&adev->ring_lru_list_lock);

	amdgpu_ring_lru_touch_locked(adev, ring);

	spin_unlock(&adev->ring_lru_list_lock);

}

/**

 * amdgpu_ring_emit_reg_write_reg_wait_helper - ring helper

 *

	const struct amdgpu_ring_funcs	*funcs;

	struct amdgpu_fence_driver	fence_drv;

	struct drm_gpu_scheduler	sched;

	struct list_head		lru_list;

	struct amdgpu_bo	*ring_obj;

	volatile uint32_t	*ring;

		     unsigned ring_size, struct amdgpu_irq_src *irq_src,

		     unsigned irq_type);

void amdgpu_ring_fini(struct amdgpu_ring *ring);

int amdgpu_ring_lru_get(struct amdgpu_device *adev, int type,

			int *blacklist, int num_blacklist,

			bool lru_pipe_order, struct amdgpu_ring **ring);

void amdgpu_ring_lru_touch(struct amdgpu_device *adev, struct amdgpu_ring *ring);

void amdgpu_ring_emit_reg_write_reg_wait_helper(struct amdgpu_ring *ring,

						uint32_t reg0, uint32_t val0,

						uint32_t reg1, uint32_t val1);