Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2f4b9400 authored by Chunming Zhou's avatar Chunming Zhou Committed by Alex Deucher
Browse files

drm/amdgpu: clean up hw semaphore support in driver 



No longer used.

Signed-off-by: default avatarChunming Zhou <David1.Zhou@amd.com>
Reviewed-by: default avatarKen Wang <Qingqing.Wang@amd.com>
Reviewed-by: default avatarMonk Liu <monk.liu@amd.com>
Signed-off-by: default avatarAlex Deucher <alexander.deucher@amd.com>
parent a8480309

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]);