[PATCH 15/21] drm/amdgpu: untie user ring ids from kernel ring ids v2

Christian K├Ânig deathsimple at vodafone.de
Fri Mar 3 13:11:34 UTC 2017


Am 02.03.2017 um 22:44 schrieb Andres Rodriguez:
> Add amdgpu_queue_mgr, a mechanism that allows disjointing usermode's
> ring ids from the kernel's ring ids.
>
> The queue manager maintains a per-file descriptor map of user ring ids
> to amdgpu_ring pointers. Once a map is created it is permanent (this is
> required to maintain FIFO execution guarantees for a context's ring).
>
> Different queue map policies can be configured for each HW IP.
> Currently all HW IPs use the identity mapper, i.e. kernel ring id is
> equal to the user ring id.
>
> The purpose of this mechanism is to distribute the load across multiple
> queues more effectively for HW IPs that support multiple rings.
> Userspace clients are unable to check whether a specific resource is in
> use by a different client. Therefore, it is up to the kernel driver to
> make the optimal choice.
>
> v2: remove amdgpu_queue_mapper_funcs

A few comments below, but apart from that looks good to me.

>
> Signed-off-by: Andres Rodriguez <andresx7 at gmail.com>
> ---
>   drivers/gpu/drm/amd/amdgpu/Makefile           |   2 +-
>   drivers/gpu/drm/amd/amdgpu/amdgpu.h           |  22 +++-
>   drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c        |  70 ++++-------
>   drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c       |   3 +
>   drivers/gpu/drm/amd/amdgpu/amdgpu_queue_mgr.c | 163 ++++++++++++++++++++++++++
>   drivers/gpu/drm/amd/amdgpu/amdgpu_queue_mgr.h |  75 ++++++++++++
>   drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c      |  45 +++++++
>   drivers/gpu/drm/amd/amdgpu/amdgpu_ring.h      |   2 +
>   8 files changed, 330 insertions(+), 52 deletions(-)
>   create mode 100644 drivers/gpu/drm/amd/amdgpu/amdgpu_queue_mgr.c
>   create mode 100644 drivers/gpu/drm/amd/amdgpu/amdgpu_queue_mgr.h
>
> diff --git a/drivers/gpu/drm/amd/amdgpu/Makefile b/drivers/gpu/drm/amd/amdgpu/Makefile
> index 2814aad..0081d0c 100644
> --- a/drivers/gpu/drm/amd/amdgpu/Makefile
> +++ b/drivers/gpu/drm/amd/amdgpu/Makefile
> @@ -17,21 +17,21 @@ amdgpu-y := amdgpu_drv.o
>   amdgpu-y += amdgpu_device.o amdgpu_kms.o \
>   	amdgpu_atombios.o atombios_crtc.o amdgpu_connectors.o \
>   	atom.o amdgpu_fence.o amdgpu_ttm.o amdgpu_object.o amdgpu_gart.o \
>   	amdgpu_encoders.o amdgpu_display.o amdgpu_i2c.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_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 \
> -	amdgpu_gtt_mgr.o amdgpu_vram_mgr.o amdgpu_virt.o
> +	amdgpu_gtt_mgr.o amdgpu_vram_mgr.o amdgpu_virt.o amdgpu_queue_mgr.o
>   
>   # add asic specific block
>   amdgpu-$(CONFIG_DRM_AMDGPU_CIK)+= cik.o cik_ih.o kv_smc.o kv_dpm.o \
>   	ci_smc.o ci_dpm.o dce_v8_0.o gfx_v7_0.o cik_sdma.o uvd_v4_2.o vce_v2_0.o \
>   	amdgpu_amdkfd_gfx_v7.o
>   
>   amdgpu-$(CONFIG_DRM_AMDGPU_SI)+= si.o gmc_v6_0.o gfx_v6_0.o si_ih.o si_dma.o dce_v6_0.o si_dpm.o si_smc.o
>   
>   amdgpu-y += \
>   	vi.o mxgpu_vi.o
> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu.h b/drivers/gpu/drm/amd/amdgpu/amdgpu.h
> index 377f58a..d3f87f4 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu.h
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu.h
> @@ -689,28 +689,45 @@ uint64_t amdgpu_ctx_add_fence(struct amdgpu_ctx *ctx, struct amdgpu_ring *ring,
>   struct dma_fence *amdgpu_ctx_get_fence(struct amdgpu_ctx *ctx,
>   				   struct amdgpu_ring *ring, uint64_t seq);
>   
>   int amdgpu_ctx_ioctl(struct drm_device *dev, void *data,
>   		     struct drm_file *filp);
>   
>   void amdgpu_ctx_mgr_init(struct amdgpu_ctx_mgr *mgr);
>   void amdgpu_ctx_mgr_fini(struct amdgpu_ctx_mgr *mgr);
>   
>   /*
> + * Queue manager related structures
> + */
> +struct amdgpu_queue_mapper;
> +
> +struct amdgpu_queue_mapper {
> +	int 		hw_ip;
> +	struct mutex	lock;
> +	/* protected by lock */
> +	struct amdgpu_ring *queue_map[AMDGPU_MAX_RINGS];
> +};
> +
> +struct amdgpu_queue_mgr {
> +	struct amdgpu_queue_mapper mapper[AMDGPU_MAX_IP_NUM];
> +};
> +
> +/*

Please put that into amdgpu_queue_mgr.h and then include 
amdgpu_queue_mgr.h in amdgpu.h, not the other way around.

>    * file private structure
>    */
>   
>   struct amdgpu_fpriv {
>   	struct amdgpu_vm	vm;
>   	struct mutex		bo_list_lock;
>   	struct idr		bo_list_handles;
>   	struct amdgpu_ctx_mgr	ctx_mgr;
> +	struct amdgpu_queue_mgr queue_mgr;

We should probably make nails with heads and put that into each context 
instead of per fd.

>   };
>   
>   /*
>    * residency list
>    */
>   
>   struct amdgpu_bo_list {
>   	struct mutex lock;
>   	struct amdgpu_bo *gds_obj;
>   	struct amdgpu_bo *gws_obj;
> @@ -1723,22 +1740,23 @@ static inline bool amdgpu_is_mec_queue_enabled(struct amdgpu_device *adev,
>   #define amdgpu_gds_switch(adev, r, v, d, w, a) (adev)->gds.funcs->patch_gds_switch((r), (v), (d), (w), (a))
>   
>   /* Common functions */
>   int amdgpu_gpu_reset(struct amdgpu_device *adev);
>   bool amdgpu_need_backup(struct amdgpu_device *adev);
>   void amdgpu_pci_config_reset(struct amdgpu_device *adev);
>   bool amdgpu_need_post(struct amdgpu_device *adev);
>   void amdgpu_update_display_priority(struct amdgpu_device *adev);
>   
>   int amdgpu_cs_parser_init(struct amdgpu_cs_parser *p, void *data);
> -int amdgpu_cs_get_ring(struct amdgpu_device *adev, u32 ip_type,
> -		       u32 ip_instance, u32 ring,
> +int amdgpu_cs_get_ring(struct amdgpu_device *adev,
> +		       struct amdgpu_queue_mgr *mgr,
> +		       u32 ip_type, u32 ip_instance, u32 user_ring,
>   		       struct amdgpu_ring **out_ring);
>   void amdgpu_cs_report_moved_bytes(struct amdgpu_device *adev, u64 num_bytes);
>   void amdgpu_ttm_placement_from_domain(struct amdgpu_bo *abo, u32 domain);
>   bool amdgpu_ttm_bo_is_amdgpu_bo(struct ttm_buffer_object *bo);
>   int amdgpu_ttm_tt_get_user_pages(struct ttm_tt *ttm, struct page **pages);
>   int amdgpu_ttm_tt_set_userptr(struct ttm_tt *ttm, uint64_t addr,
>   				     uint32_t flags);
>   bool amdgpu_ttm_tt_has_userptr(struct ttm_tt *ttm);
>   struct mm_struct *amdgpu_ttm_tt_get_usermm(struct ttm_tt *ttm);
>   bool amdgpu_ttm_tt_affect_userptr(struct ttm_tt *ttm, unsigned long start,
> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
> index 57301f5..605d40e 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
> @@ -22,74 +22,42 @@
>    * DEALINGS IN THE SOFTWARE.
>    *
>    * Authors:
>    *    Jerome Glisse <glisse at freedesktop.org>
>    */
>   #include <linux/pagemap.h>
>   #include <drm/drmP.h>
>   #include <drm/amdgpu_drm.h>
>   #include "amdgpu.h"
>   #include "amdgpu_trace.h"
> +#include "amdgpu_queue_mgr.h"
>   
> -int amdgpu_cs_get_ring(struct amdgpu_device *adev, u32 ip_type,
> -		       u32 ip_instance, u32 ring,
> +int amdgpu_cs_get_ring(struct amdgpu_device *adev,
> +		       struct amdgpu_queue_mgr *mgr,
> +		       u32 ip_type, u32 ip_instance, u32 user_ring,
>   		       struct amdgpu_ring **out_ring)
>   {
> +	int r;
> +
>   	/* Right now all IPs have only one instance - multiple rings. */
>   	if (ip_instance != 0) {
>   		DRM_ERROR("invalid ip instance: %d\n", ip_instance);
>   		return -EINVAL;
>   	}
>   
> -	switch (ip_type) {
> -	default:
> -		DRM_ERROR("unknown ip type: %d\n", ip_type);
> -		return -EINVAL;
> -	case AMDGPU_HW_IP_GFX:
> -		if (ring < adev->gfx.num_gfx_rings) {
> -			*out_ring = &adev->gfx.gfx_ring[ring];
> -		} else {
> -			DRM_ERROR("only %d gfx rings are supported now\n",
> -				  adev->gfx.num_gfx_rings);
> -			return -EINVAL;
> -		}
> -		break;
> -	case AMDGPU_HW_IP_COMPUTE:
> -		if (ring < adev->gfx.num_compute_rings) {
> -			*out_ring = &adev->gfx.compute_ring[ring];
> -		} else {
> -			DRM_ERROR("only %d compute rings are supported now\n",
> -				  adev->gfx.num_compute_rings);
> -			return -EINVAL;
> -		}
> -		break;
> -	case AMDGPU_HW_IP_DMA:
> -		if (ring < adev->sdma.num_instances) {
> -			*out_ring = &adev->sdma.instance[ring].ring;
> -		} else {
> -			DRM_ERROR("only %d SDMA rings are supported\n",
> -				  adev->sdma.num_instances);
> -			return -EINVAL;
> -		}
> -		break;
> -	case AMDGPU_HW_IP_UVD:
> -		*out_ring = &adev->uvd.ring;
> -		break;
> -	case AMDGPU_HW_IP_VCE:
> -		if (ring < adev->vce.num_rings){
> -			*out_ring = &adev->vce.ring[ring];
> -		} else {
> -			DRM_ERROR("only %d VCE rings are supported\n", adev->vce.num_rings);
> -			return -EINVAL;
> -		}
> -		break;
> +	r = amdgpu_queue_mgr_map(adev, mgr, ip_type, user_ring, out_ring);
> +	if (r) {
> +		DRM_ERROR("unable to map userspace ip:%d ring:%d to kernel ring\n",
> +				ip_type, user_ring);
> +		return r;
>   	}
> +

You should probably also add the instance check and error messages to 
amdgpu_queue_mgr_map() and remove this function entirely.

>   	return 0;
>   }
>   
>   static int amdgpu_cs_user_fence_chunk(struct amdgpu_cs_parser *p,
>   				      struct drm_amdgpu_cs_chunk_fence *data,
>   				      uint32_t *offset)
>   {
>   	struct drm_gem_object *gobj;
>   	unsigned long size;
>   
> @@ -868,21 +836,21 @@ static int amdgpu_cs_ib_fill(struct amdgpu_device *adev,
>   		struct drm_amdgpu_cs_chunk_ib *chunk_ib;
>   		struct amdgpu_ring *ring;
>   
>   		chunk = &parser->chunks[i];
>   		ib = &parser->job->ibs[j];
>   		chunk_ib = (struct drm_amdgpu_cs_chunk_ib *)chunk->kdata;
>   
>   		if (chunk->chunk_id != AMDGPU_CHUNK_ID_IB)
>   			continue;
>   
> -		r = amdgpu_cs_get_ring(adev, chunk_ib->ip_type,
> +		r = amdgpu_cs_get_ring(adev, &fpriv->queue_mgr, chunk_ib->ip_type,
>   				       chunk_ib->ip_instance, chunk_ib->ring,
>   				       &ring);
>   		if (r)
>   			return r;
>   
>   		if (ib->flags & AMDGPU_IB_FLAG_PREAMBLE) {
>   			parser->job->preamble_status |= AMDGPU_PREAMBLE_IB_PRESENT;
>   			if (!parser->ctx->preamble_presented) {
>   				parser->job->preamble_status |= AMDGPU_PREAMBLE_IB_PRESENT_FIRST;
>   				parser->ctx->preamble_presented = true;
> @@ -972,21 +940,22 @@ static int amdgpu_cs_dependencies(struct amdgpu_device *adev,
>   
>   		deps = (struct drm_amdgpu_cs_chunk_dep *)chunk->kdata;
>   		num_deps = chunk->length_dw * 4 /
>   			sizeof(struct drm_amdgpu_cs_chunk_dep);
>   
>   		for (j = 0; j < num_deps; ++j) {
>   			struct amdgpu_ring *ring;
>   			struct amdgpu_ctx *ctx;
>   			struct dma_fence *fence;
>   
> -			r = amdgpu_cs_get_ring(adev, deps[j].ip_type,
> +			r = amdgpu_cs_get_ring(adev, &fpriv->queue_mgr,
> +					       deps[j].ip_type,
>   					       deps[j].ip_instance,
>   					       deps[j].ring, &ring);
>   			if (r)
>   				return r;
>   
>   			ctx = amdgpu_ctx_get(fpriv, deps[j].ctx_id);
>   			if (ctx == NULL)
>   				return -EINVAL;
>   
>   			fence = amdgpu_ctx_get_fence(ctx, ring,
> @@ -1099,29 +1068,31 @@ int amdgpu_cs_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
>    *
>    * @dev: drm device
>    * @data: data from userspace
>    * @filp: file private
>    *
>    * Wait for the command submission identified by handle to finish.
>    */
>   int amdgpu_cs_wait_ioctl(struct drm_device *dev, void *data,
>   			 struct drm_file *filp)
>   {
> +	struct amdgpu_fpriv *fpriv = filp->driver_priv;
>   	union drm_amdgpu_wait_cs *wait = data;
>   	struct amdgpu_device *adev = dev->dev_private;
>   	unsigned long timeout = amdgpu_gem_timeout(wait->in.timeout);
>   	struct amdgpu_ring *ring = NULL;
>   	struct amdgpu_ctx *ctx;
>   	struct dma_fence *fence;
>   	long r;
>   
> -	r = amdgpu_cs_get_ring(adev, wait->in.ip_type, wait->in.ip_instance,
> +	r = amdgpu_cs_get_ring(adev, &fpriv->queue_mgr,
> +			       wait->in.ip_type, wait->in.ip_instance,
>   			       wait->in.ring, &ring);
>   	if (r)
>   		return r;
>   
>   	ctx = amdgpu_ctx_get(filp->driver_priv, wait->in.ctx_id);
>   	if (ctx == NULL)
>   		return -EINVAL;
>   
>   	fence = amdgpu_ctx_get_fence(ctx, ring, wait->in.handle);
>   	if (IS_ERR(fence))
> @@ -1149,24 +1120,25 @@ int amdgpu_cs_wait_ioctl(struct drm_device *dev, void *data,
>    * @filp: file private
>    * @user: drm_amdgpu_fence copied from user space
>    */
>   static struct dma_fence *amdgpu_cs_get_fence(struct amdgpu_device *adev,
>   					     struct drm_file *filp,
>   					     struct drm_amdgpu_fence *user)
>   {
>   	struct amdgpu_ring *ring;
>   	struct amdgpu_ctx *ctx;
>   	struct dma_fence *fence;
> +	struct amdgpu_fpriv *fpriv = filp->driver_priv;
>   	int r;
>   
> -	r = amdgpu_cs_get_ring(adev, user->ip_type, user->ip_instance,
> -			       user->ring, &ring);
> +	r = amdgpu_cs_get_ring(adev, &fpriv->queue_mgr, user->ip_type,
> +			       user->ip_instance, user->ring, &ring);
>   	if (r)
>   		return ERR_PTR(r);
>   
>   	ctx = amdgpu_ctx_get(filp->driver_priv, user->ctx_id);
>   	if (ctx == NULL)
>   		return ERR_PTR(-EINVAL);
>   
>   	fence = amdgpu_ctx_get_fence(ctx, ring, user->seq_no);
>   	amdgpu_ctx_put(ctx);
>   
> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
> index 61d94c7..0932ade 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
> @@ -23,20 +23,21 @@
>    *
>    * Authors: Dave Airlie
>    *          Alex Deucher
>    *          Jerome Glisse
>    */
>   #include <drm/drmP.h>
>   #include "amdgpu.h"
>   #include <drm/amdgpu_drm.h>
>   #include "amdgpu_uvd.h"
>   #include "amdgpu_vce.h"
> +#include "amdgpu_queue_mgr.h"
>   
>   #include <linux/vga_switcheroo.h>
>   #include <linux/slab.h>
>   #include <linux/pm_runtime.h>
>   #include "amdgpu_amdkfd.h"
>   
>   #if defined(CONFIG_VGA_SWITCHEROO)
>   bool amdgpu_has_atpx(void);
>   #else
>   static inline bool amdgpu_has_atpx(void) { return false; }
> @@ -658,20 +659,21 @@ int amdgpu_driver_open_kms(struct drm_device *dev, struct drm_file *file_priv)
>   	if (amdgpu_sriov_vf(adev)) {
>   		r = amdgpu_map_static_csa(adev, &fpriv->vm);
>   		if (r)
>   			goto out_suspend;
>   	}
>   
>   	mutex_init(&fpriv->bo_list_lock);
>   	idr_init(&fpriv->bo_list_handles);
>   
>   	amdgpu_ctx_mgr_init(&fpriv->ctx_mgr);
> +	amdgpu_queue_mgr_init(adev, &fpriv->queue_mgr);
>   
>   	file_priv->driver_priv = fpriv;
>   
>   out_suspend:
>   	pm_runtime_mark_last_busy(dev->dev);
>   	pm_runtime_put_autosuspend(dev->dev);
>   
>   	return r;
>   }
>   
> @@ -687,20 +689,21 @@ void amdgpu_driver_postclose_kms(struct drm_device *dev,
>   				 struct drm_file *file_priv)
>   {
>   	struct amdgpu_device *adev = dev->dev_private;
>   	struct amdgpu_fpriv *fpriv = file_priv->driver_priv;
>   	struct amdgpu_bo_list *list;
>   	int handle;
>   
>   	if (!fpriv)
>   		return;
>   
> +	amdgpu_queue_mgr_fini(adev, &fpriv->queue_mgr);
>   	amdgpu_ctx_mgr_fini(&fpriv->ctx_mgr);
>   
>   	amdgpu_uvd_free_handles(adev, file_priv);
>   	amdgpu_vce_free_handles(adev, file_priv);
>   
>   	if (amdgpu_sriov_vf(adev)) {
>   		/* TODO: how to handle reserve failure */
>   		BUG_ON(amdgpu_bo_reserve(adev->virt.csa_obj, false));
>   		amdgpu_vm_bo_rmv(adev, fpriv->vm.csa_bo_va);
>   		fpriv->vm.csa_bo_va = NULL;
> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_queue_mgr.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_queue_mgr.c
> new file mode 100644
> index 0000000..cafe913
> --- /dev/null
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_queue_mgr.c
> @@ -0,0 +1,163 @@
> +/*
> + * Copyright 2017 Valve Corporation
> + *
> + * 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, sublicense,
> + * 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 above copyright notice and this permission notice shall be included in
> + * all copies or substantial portions of the Software.
> + *
> + * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
> + * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) 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.
> + *
> + * Authors: Andres Rodriguez
> + */
> +
> +#include "amdgpu_ring.h"
> +#include "amdgpu_queue_mgr.h"
> +
> +static int amdgpu_queue_mapper_init(struct amdgpu_queue_mapper *mapper,
> +				    int hw_ip)
> +{
> +	if (!mapper)
> +		return -EINVAL;
> +
> +	if (hw_ip > AMDGPU_MAX_IP_NUM)
> +		return -EINVAL;
> +
> +	mapper->hw_ip = hw_ip;
> +	mutex_init(&mapper->lock);
> +
> +	memset(mapper->queue_map, 0, sizeof(mapper->queue_map));
> +
> +	return 0;
> +}
> +
> +static struct amdgpu_ring *get_cached_map(struct amdgpu_queue_mapper *mapper,
> +					  int ring)
> +{
> +	return mapper->queue_map[ring];
> +}
Do you really need a helper function for that? Especially since it 
doesn't have an amdgpu_ prefix.

> +
> +static int update_cached_map(struct amdgpu_queue_mapper *mapper,
> +			     int ring, struct amdgpu_ring *pring)
> +{
> +	if (WARN_ON(mapper->queue_map[ring])) {
> +		DRM_ERROR("Un-expected ring re-map\n");
> +		return -EINVAL;
> +	}
> +
> +	mapper->queue_map[ring] = pring;
> +
> +	return 0;
> +}

Dito.

> +
> +static int amdgpu_identity_map(struct amdgpu_device *adev,
> +			       struct amdgpu_queue_mapper *mapper,
> +			       int ring,
> +			       struct amdgpu_ring **out_ring)
> +{
> +	switch (mapper->hw_ip) {
> +	case AMDGPU_HW_IP_GFX:
> +		*out_ring = &adev->gfx.gfx_ring[ring];
> +		break;
> +	case AMDGPU_HW_IP_COMPUTE:
> +		*out_ring = &adev->gfx.compute_ring[ring];
> +		break;
> +	case AMDGPU_HW_IP_DMA:
> +		*out_ring = &adev->sdma.instance[ring].ring;
> +		break;
> +	case AMDGPU_HW_IP_UVD:
> +		*out_ring = &adev->uvd.ring;
> +		break;
> +	case AMDGPU_HW_IP_VCE:
> +		*out_ring = &adev->vce.ring[ring];
> +		break;
> +	default:
> +		*out_ring = NULL;
> +		DRM_ERROR("unknown HW IP type: %d\n", mapper->hw_ip);
> +		return -EINVAL;
> +	}
> +
> +	return update_cached_map(mapper, ring, *out_ring);
> +}
> +
> +int amdgpu_queue_mgr_init(struct amdgpu_device *adev,
> +			  struct amdgpu_queue_mgr *mgr)
> +{
> +	int i;
> +
> +	if (!adev || !mgr)
> +		return -EINVAL;
> +
> +	memset(mgr, 0, sizeof(*mgr));
> +
> +	for (i = 0; i < AMDGPU_MAX_IP_NUM; ++i)
> +		amdgpu_queue_mapper_init(&mgr->mapper[i], i);
> +
> +	return 0;
> +}
> +
> +int amdgpu_queue_mgr_fini(struct amdgpu_device *adev,
> +			  struct amdgpu_queue_mgr *mgr)
> +{
> +	return 0;
> +}
> +
> +int amdgpu_queue_mgr_map(struct amdgpu_device *adev,
> +			 struct amdgpu_queue_mgr *mgr,
> +			 int hw_ip, int ring,
> +			 struct amdgpu_ring **out_ring)
> +{
> +	int r;
> +	struct amdgpu_queue_mapper *mapper = &mgr->mapper[hw_ip];
> +
> +	if (!adev || !mgr || !out_ring)
> +		return -EINVAL;
> +
> +	if (hw_ip >= AMDGPU_MAX_IP_NUM)
> +		return -EINVAL;
> +
> +	if (ring >= AMDGPU_MAX_RINGS)
> +		return -EINVAL;
> +
> +	r = amdgpu_ring_is_valid_index(adev, hw_ip, ring);
> +	if (r)
> +		return r;
> +
> +	mutex_lock(&mapper->lock);
> +
> +	*out_ring = get_cached_map(mapper, ring);
> +	if (*out_ring) {
> +		/* cache hit */
> +		r = 0;
> +		goto out_unlock;
> +	}
> +
> +	switch (mapper->hw_ip) {
> +	case AMDGPU_HW_IP_GFX:
> +	case AMDGPU_HW_IP_COMPUTE:
> +	case AMDGPU_HW_IP_DMA:
> +	case AMDGPU_HW_IP_UVD:
> +	case AMDGPU_HW_IP_VCE:
> +		r = amdgpu_identity_map(adev, mapper, ring, out_ring);
> +		break;
> +	default:
> +		*out_ring = NULL;
> +		r = -EINVAL;
> +		DRM_ERROR("unknown HW IP type: %d\n", mapper->hw_ip);
> +	}
> +
> +out_unlock:
> +	mutex_unlock(&mapper->lock);
> +	return r;
> +}
> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_queue_mgr.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_queue_mgr.h
> new file mode 100644
> index 0000000..a85bb32
> --- /dev/null
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_queue_mgr.h
> @@ -0,0 +1,75 @@
> +/*
> + * Copyright 2017 Valve Corporation
> + *
> + * 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, sublicense,
> + * 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 above copyright notice and this permission notice shall be included in
> + * all copies or substantial portions of the Software.
> + *
> + * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
> + * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) 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.
> + *
> + * Authors:
> + * 	Andres Rodriguez <andresx7 at gmail.com>
> + */
> +
> +#ifndef __AMDGPU_QUEUE_MGR_H__
> +#define __AMDGPU_QUEUE_MGR_H__
> +
> +#include "amdgpu.h"
> +
> +/**
> + * amdgpu_queue_mgr_init - init an amdgpu_queue_mgr struct
> + *
> + * @adev: amdgpu_device pointer
> + * @mgr: amdgpu_queue_mgr structure holding queue information
> + *
> + * Initialize the the selected @mgr (all asics).
> + *
> + * Returns 0 on success, error on failure.
> + */

We usually put the comments in the implementation, not the headers IIRC 
(but might be wrong on this).

> +int amdgpu_queue_mgr_init(struct amdgpu_device *adev,
> +			  struct amdgpu_queue_mgr *mgr);
> +
> +/**
> + * amdgpu_queue_mgr_fini - de-initialize an amdgpu_queue_mgr struct
> + *
> + * @adev: amdgpu_device pointer
> + * @mgr: amdgpu_queue_mgr structure holding queue information
> + *
> + * De-initialize the the selected @mgr (all asics).
> + *
> + * Returns 0 on success, error on failure.
> + */
> +int amdgpu_queue_mgr_fini(struct amdgpu_device *adev,
> +			  struct amdgpu_queue_mgr *mgr);
> +
> +/**
> + * amdgpu_queue_mgr_map - Map a userspace ring id to an amdgpu_ring
> + *
> + * @adev: amdgpu_device pointer
> + * @mgr: amdgpu_queue_mgr structure holding queue information
> + * @hw_ip: HW IP enum
> + * @ring: user ring id
> + * @our_ring: pointer to mapped amdgpu_ring
> + *
> + * Map a userspace ring id to an appropriate kernel ring. Different
> + * policies are configurable at a HW IP level.
> + *
> + * Returns 0 on success, error on failure.
> + */
> +int amdgpu_queue_mgr_map(struct amdgpu_device *adev,
> +			 struct amdgpu_queue_mgr *mgr,
> +			 int hw_ip, int ring,
> +			 struct amdgpu_ring **out_ring);
> +#endif
> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c
> index 7c842b7..43cd539 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c
> @@ -45,20 +45,65 @@
>    * pointers are equal, the ring is idle.  When the host
>    * writes commands to the ring buffer, it increments the
>    * wptr.  The GPU then starts fetching commands and executes
>    * them until the pointers are equal again.
>    */
>   static int amdgpu_debugfs_ring_init(struct amdgpu_device *adev,
>   				    struct amdgpu_ring *ring);
>   static void amdgpu_debugfs_ring_fini(struct amdgpu_ring *ring);
>   
>   /**
> + * amdgpu_ring_is_valid_index - check if a ring idex is valid for a HW IP
> + *
> + * @adev: amdgpu_device pointer
> + * @ip_type: The HW IP to check against
> + * @ring: the ring index
> + *
> + * Check if @ring is a valid index for @ip_type (all asics).
> + * Returns 0 on success, error on failure.
> + */
> +int amdgpu_ring_is_valid_index(struct amdgpu_device *adev,
> +			       int ip_type, int ring)
> +{
> +	int ip_num_rings;
> +
> +	switch (ip_type) {
> +	case AMDGPU_HW_IP_GFX:
> +		ip_num_rings = adev->gfx.num_gfx_rings;
> +		break;
> +	case AMDGPU_HW_IP_COMPUTE:
> +		ip_num_rings = adev->gfx.num_compute_rings;
> +		break;
> +	case AMDGPU_HW_IP_DMA:
> +		ip_num_rings = adev->sdma.num_instances;
> +		break;
> +	case AMDGPU_HW_IP_UVD:
> +		ip_num_rings = 1;
> +		break;
> +	case AMDGPU_HW_IP_VCE:
> +		ip_num_rings = adev->vce.num_rings;
> +		break;
> +	default:
> +		DRM_ERROR("unknown ip type: %d\n", ip_type);
> +		return -EINVAL;
> +	}
> +
> +	if (ring >= ip_num_rings) {
> +		DRM_ERROR("Ring index:%d exceeds maximum:%d for ip:%d\n",
> +				ring, ip_num_rings, ip_type);
> +		return -EINVAL;
> +	}
> +
> +	return 0;
> +}
> +
> +/**

This doesn't belong here. ip_type is part of the IOCTL interface.

Either put that into amdgpu_cs.c or even better into amdgpu_queue_mgr.c.

>    * amdgpu_ring_alloc - allocate space on the ring buffer
>    *
>    * @adev: amdgpu_device pointer
>    * @ring: amdgpu_ring structure holding ring information
>    * @ndw: number of dwords to allocate in the ring buffer
>    *
>    * Allocate @ndw dwords in the ring buffer (all asics).
>    * Returns 0 on success, error on failure.
>    */
>   int amdgpu_ring_alloc(struct amdgpu_ring *ring, unsigned ndw)
> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.h
> index 2345b398..35da5c5 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.h
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.h
> @@ -168,20 +168,22 @@ struct amdgpu_ring {
>   	uint64_t		current_ctx;
>   	char			name[16];
>   	unsigned		cond_exe_offs;
>   	u64			cond_exe_gpu_addr;
>   	volatile u32		*cond_exe_cpu_addr;
>   #if defined(CONFIG_DEBUG_FS)
>   	struct dentry *ent;
>   #endif
>   };
>   
> +int amdgpu_ring_is_valid_index(struct amdgpu_device *adev,
> +			       int hw_ip, int ring);
>   int amdgpu_ring_alloc(struct amdgpu_ring *ring, unsigned ndw);
>   void amdgpu_ring_insert_nop(struct amdgpu_ring *ring, uint32_t count);
>   void amdgpu_ring_generic_pad_ib(struct amdgpu_ring *ring, struct amdgpu_ib *ib);
>   void amdgpu_ring_commit(struct amdgpu_ring *ring);
>   void amdgpu_ring_undo(struct amdgpu_ring *ring);
>   int amdgpu_ring_init(struct amdgpu_device *adev, struct amdgpu_ring *ring,
>   		     unsigned ring_size, struct amdgpu_irq_src *irq_src,
>   		     unsigned irq_type);
>   void amdgpu_ring_fini(struct amdgpu_ring *ring);
>   




More information about the amd-gfx mailing list