drm/amdgpu: clean up hw semaphore support in driver (2f4b9400) · Commits · github.com / kvm-riscv / linux

drivers/gpu/drm/amd/amdgpu/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -20,7 +20,7 @@ amdgpu-y += amdgpu_device.o amdgpu_kms.o \
		amdgpu_fb.o amdgpu_gem.o amdgpu_ring.o \
		amdgpu_cs.o amdgpu_bios.o amdgpu_benchmark.o amdgpu_test.o \
		amdgpu_pm.o atombios_dp.o amdgpu_afmt.o amdgpu_trace_points.o \
		atombios_encoders.o amdgpu_semaphore.o amdgpu_sa.o atombios_i2c.o \
		atombios_encoders.o amdgpu_sa.o atombios_i2c.o \
		amdgpu_prime.o amdgpu_vm.o amdgpu_ib.o amdgpu_pll.o \
		amdgpu_ucode.o amdgpu_bo_list.o amdgpu_ctx.o amdgpu_sync.o

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

+0 −21

Original line number	Diff line number	Diff line
		@@ -638,31 +638,10 @@ int amdgpu_mode_dumb_create(struct drm_file *file_priv,
		int amdgpu_mode_dumb_mmap(struct drm_file *filp,
		struct drm_device *dev,
		uint32_t handle, uint64_t *offset_p);

		/*
		* Semaphores.
		*/
		struct amdgpu_semaphore {
		struct amdgpu_sa_bo *sa_bo;
		signed waiters;
		uint64_t gpu_addr;
		};

		int amdgpu_semaphore_create(struct amdgpu_device *adev,
		struct amdgpu_semaphore **semaphore);
		bool amdgpu_semaphore_emit_signal(struct amdgpu_ring *ring,
		struct amdgpu_semaphore *semaphore);
		bool amdgpu_semaphore_emit_wait(struct amdgpu_ring *ring,
		struct amdgpu_semaphore *semaphore);
		void amdgpu_semaphore_free(struct amdgpu_device *adev,
		struct amdgpu_semaphore **semaphore,
		struct fence *fence);

		/*
		* Synchronization
		*/
		struct amdgpu_sync {
		struct amdgpu_semaphore *semaphores[AMDGPU_NUM_SYNCS];
		struct fence *sync_to[AMDGPU_MAX_RINGS];
		DECLARE_HASHTABLE(fences, 4);
		struct fence *last_vm_update;

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

+0 −4

Original line number	Diff line number	Diff line
		@@ -81,7 +81,6 @@ int amdgpu_exp_hw_support = 0;
		int amdgpu_enable_scheduler = 1;
		int amdgpu_sched_jobs = 32;
		int amdgpu_sched_hw_submission = 2;
		int amdgpu_enable_semaphores = 0;
		int amdgpu_powerplay = -1;

		MODULE_PARM_DESC(vramlimit, "Restrict VRAM for testing, in megabytes");
		@@ -162,9 +161,6 @@ module_param_named(sched_jobs, amdgpu_sched_jobs, int, 0444);
		MODULE_PARM_DESC(sched_hw_submission, "the max number of HW submissions (default 2)");
		module_param_named(sched_hw_submission, amdgpu_sched_hw_submission, int, 0444);

		MODULE_PARM_DESC(enable_semaphores, "Enable semaphores (1 = enable, 0 = disable (default))");
		module_param_named(enable_semaphores, amdgpu_enable_semaphores, int, 0644);

		#ifdef CONFIG_DRM_AMD_POWERPLAY
		MODULE_PARM_DESC(powerplay, "Powerplay component (1 = enable, 0 = disable, -1 = auto (default))");
		module_param_named(powerplay, amdgpu_powerplay, int, 0444);

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

deleted100644 → 0

+0 −102

Original line number	Diff line number	Diff line
		/*
		* Copyright 2011 Christian König.
		* All Rights Reserved.
		*
		* 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 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 COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS 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.
		*
		* The above copyright notice and this permission notice (including the
		* next paragraph) shall be included in all copies or substantial portions
		* of the Software.
		*
		*/
		/*
		* Authors:
		* Christian König <deathsimple@vodafone.de>
		*/
		#include <drm/drmP.h>
		#include "amdgpu.h"
		#include "amdgpu_trace.h"

		int amdgpu_semaphore_create(struct amdgpu_device *adev,
		struct amdgpu_semaphore **semaphore)
		{
		int r;

		*semaphore = kmalloc(sizeof(struct amdgpu_semaphore), GFP_KERNEL);
		if (*semaphore == NULL) {
		return -ENOMEM;
		}
		r = amdgpu_sa_bo_new(&adev->ring_tmp_bo,
		&(*semaphore)->sa_bo, 8, 8);
		if (r) {
		kfree(*semaphore);
		*semaphore = NULL;
		return r;
		}
		(*semaphore)->waiters = 0;
		(semaphore)->gpu_addr = amdgpu_sa_bo_gpu_addr((semaphore)->sa_bo);

		((uint64_t )amdgpu_sa_bo_cpu_addr((*semaphore)->sa_bo)) = 0;

		return 0;
		}

		bool amdgpu_semaphore_emit_signal(struct amdgpu_ring *ring,
		struct amdgpu_semaphore *semaphore)
		{
		trace_amdgpu_semaphore_signale(ring->idx, semaphore);

		if (amdgpu_ring_emit_semaphore(ring, semaphore, false)) {
		--semaphore->waiters;

		/* for debugging lockup only, used by sysfs debug files */
		ring->last_semaphore_signal_addr = semaphore->gpu_addr;
		return true;
		}
		return false;
		}

		bool amdgpu_semaphore_emit_wait(struct amdgpu_ring *ring,
		struct amdgpu_semaphore *semaphore)
		{
		trace_amdgpu_semaphore_wait(ring->idx, semaphore);

		if (amdgpu_ring_emit_semaphore(ring, semaphore, true)) {
		++semaphore->waiters;

		/* for debugging lockup only, used by sysfs debug files */
		ring->last_semaphore_wait_addr = semaphore->gpu_addr;
		return true;
		}
		return false;
		}

		void amdgpu_semaphore_free(struct amdgpu_device *adev,
		struct amdgpu_semaphore **semaphore,
		struct fence *fence)
		{
		if (semaphore == NULL \|\| *semaphore == NULL) {
		return;
		}
		if ((*semaphore)->waiters > 0) {
		dev_err(adev->dev, "semaphore %p has more waiters than signalers,"
		" hardware lockup imminent!\n", *semaphore);
		}
		amdgpu_sa_bo_free(adev, &(*semaphore)->sa_bo, fence);
		kfree(*semaphore);
		*semaphore = NULL;
		}

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

+4 −60

Original line number	Diff line number	Diff line
		@@ -48,9 +48,6 @@ void amdgpu_sync_create(struct amdgpu_sync *sync)
		{
		unsigned i;

		for (i = 0; i < AMDGPU_NUM_SYNCS; ++i)
		sync->semaphores[i] = NULL;

		for (i = 0; i < AMDGPU_MAX_RINGS; ++i)
		sync->sync_to[i] = NULL;

		@@ -153,13 +150,13 @@ static void amdgpu_sync_get_owner(struct fence f)
		}

		/**
		* amdgpu_sync_resv - use the semaphores to sync to a reservation object
		* amdgpu_sync_resv - sync to a reservation object
		*
		* @sync: sync object to add fences from reservation object to
		* @resv: reservation object with embedded fence
		* @shared: true if we should only sync to the exclusive fence
		*
		* Sync to the fence using the semaphore objects
		* Sync to the fence
		*/
		int amdgpu_sync_resv(struct amdgpu_device *adev,
		struct amdgpu_sync *sync,
		@@ -250,9 +247,6 @@ int amdgpu_sync_wait(struct amdgpu_sync *sync)
		kfree(e);
		}

		if (amdgpu_enable_semaphores)
		return 0;

		for (i = 0; i < AMDGPU_MAX_RINGS; ++i) {
		struct fence *fence = sync->sync_to[i];
		if (!fence)
		@@ -279,12 +273,10 @@ int amdgpu_sync_rings(struct amdgpu_sync *sync,
		struct amdgpu_ring *ring)
		{
		struct amdgpu_device *adev = ring->adev;
		unsigned count = 0;
		int i, r;

		for (i = 0; i < AMDGPU_MAX_RINGS; ++i) {
		struct amdgpu_ring *other = adev->rings[i];
		struct amdgpu_semaphore *semaphore;
		struct amdgpu_fence *fence;

		if (!sync->sync_to[i])
		@@ -292,64 +284,19 @@ int amdgpu_sync_rings(struct amdgpu_sync *sync,

		fence = to_amdgpu_fence(sync->sync_to[i]);

		/* check if we really need to sync */
		if (!amdgpu_enable_scheduler &&
		!amdgpu_fence_need_sync(fence, ring))
		continue;

		/* prevent GPU deadlocks */
		if (!other->ready) {
		dev_err(adev->dev, "Syncing to a disabled ring!");
		return -EINVAL;
		}

		if (amdgpu_enable_scheduler \|\| !amdgpu_enable_semaphores) {
		if (amdgpu_enable_scheduler) {
		r = fence_wait(sync->sync_to[i], true);
		if (r)
		return r;
		continue;
		}

		if (count >= AMDGPU_NUM_SYNCS) {
		/* not enough room, wait manually */
		r = fence_wait(&fence->base, false);
		if (r)
		return r;
		continue;
		}
		r = amdgpu_semaphore_create(adev, &semaphore);
		if (r)
		return r;

		sync->semaphores[count++] = semaphore;

		/* allocate enough space for sync command */
		r = amdgpu_ring_alloc(other, 16);
		if (r)
		return r;

		/* emit the signal semaphore */
		if (!amdgpu_semaphore_emit_signal(other, semaphore)) {
		/* signaling wasn't successful wait manually */
		amdgpu_ring_undo(other);
		r = fence_wait(&fence->base, false);
		if (r)
		return r;
		continue;
		}

		/* we assume caller has already allocated space on waiters ring */
		if (!amdgpu_semaphore_emit_wait(ring, semaphore)) {
		/* waiting wasn't successful wait manually */
		amdgpu_ring_undo(other);
		r = fence_wait(&fence->base, false);
		if (r)
		return r;
		continue;
		}

		amdgpu_ring_commit(other);
		amdgpu_fence_note_sync(fence, ring);
		}

		return 0;
		@@ -362,7 +309,7 @@ int amdgpu_sync_rings(struct amdgpu_sync *sync,
		* @sync: sync object to use
		* @fence: fence to use for the free
		*
		* Free the sync object by freeing all semaphores in it.
		* Free the sync object.
		*/
		void amdgpu_sync_free(struct amdgpu_device *adev,
		struct amdgpu_sync *sync,
		@@ -378,9 +325,6 @@ void amdgpu_sync_free(struct amdgpu_device *adev,
		kfree(e);
		}

		for (i = 0; i < AMDGPU_NUM_SYNCS; ++i)
		amdgpu_semaphore_free(adev, &sync->semaphores[i], fence);

		for (i = 0; i < AMDGPU_MAX_RINGS; ++i)
		fence_put(sync->sync_to[i]);