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

   1 /*
   2  * Copyright 2017 Valve Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * Authors: Andres Rodriguez
  23  */
  24
  25 #include "amdgpu.h"
  26 #include "amdgpu_ring.h"
  27
  28 static int amdgpu_queue_mapper_init(struct amdgpu_queue_mapper *mapper,
  29                                     int hw_ip)
  30 {
  31         if (!mapper)
  32                 return -EINVAL;
  33
  34         if (hw_ip > AMDGPU_MAX_IP_NUM)
  35                 return -EINVAL;
  36
  37         mapper->hw_ip = hw_ip;
  38         mutex_init(&mapper->lock);
  39
  40         memset(mapper->queue_map, 0, sizeof(mapper->queue_map));
  41
  42         return 0;
  43 }
  44
  45 static struct amdgpu_ring *amdgpu_get_cached_map(struct amdgpu_queue_mapper *mapper,
  46                                           int ring)
  47 {
  48         return mapper->queue_map[ring];
  49 }
  50
  51 static int amdgpu_update_cached_map(struct amdgpu_queue_mapper *mapper,
  52                              int ring, struct amdgpu_ring *pring)
  53 {
  54         if (WARN_ON(mapper->queue_map[ring])) {
  55                 DRM_ERROR("Un-expected ring re-map\n");
  56                 return -EINVAL;
  57         }
  58
  59         mapper->queue_map[ring] = pring;
  60
  61         return 0;
  62 }
  63
  64 static int amdgpu_identity_map(struct amdgpu_device *adev,
  65                                struct amdgpu_queue_mapper *mapper,
  66                                int ring,
  67                                struct amdgpu_ring **out_ring)
  68 {
  69         switch (mapper->hw_ip) {
  70         case AMDGPU_HW_IP_GFX:
  71                 *out_ring = &adev->gfx.gfx_ring[ring];
  72                 break;
  73         case AMDGPU_HW_IP_COMPUTE:
  74                 *out_ring = &adev->gfx.compute_ring[ring];
  75                 break;
  76         case AMDGPU_HW_IP_DMA:
  77                 *out_ring = &adev->sdma.instance[ring].ring;
  78                 break;
  79         case AMDGPU_HW_IP_UVD:
  80                 *out_ring = &adev->uvd.ring;
  81                 break;
  82         case AMDGPU_HW_IP_VCE:
  83                 *out_ring = &adev->vce.ring[ring];
  84                 break;
  85         case AMDGPU_HW_IP_UVD_ENC:
  86                 *out_ring = &adev->uvd.ring_enc[ring];
  87                 break;
  88         case AMDGPU_HW_IP_VCN_DEC:
  89                 *out_ring = &adev->vcn.ring_dec;
  90                 break;
  91         case AMDGPU_HW_IP_VCN_ENC:
  92                 *out_ring = &adev->vcn.ring_enc[ring];
  93                 break;
  94         default:
  95                 *out_ring = NULL;
  96                 DRM_ERROR("unknown HW IP type: %d\n", mapper->hw_ip);
  97                 return -EINVAL;
  98         }
  99
 100         return amdgpu_update_cached_map(mapper, ring, *out_ring);
 101 }
 102
 103 static enum amdgpu_ring_type amdgpu_hw_ip_to_ring_type(int hw_ip)
 104 {
 105         switch (hw_ip) {
 106         case AMDGPU_HW_IP_GFX:
 107                 return AMDGPU_RING_TYPE_GFX;
 108         case AMDGPU_HW_IP_COMPUTE:
 109                 return AMDGPU_RING_TYPE_COMPUTE;
 110         case AMDGPU_HW_IP_DMA:
 111                 return AMDGPU_RING_TYPE_SDMA;
 112         case AMDGPU_HW_IP_UVD:
 113                 return AMDGPU_RING_TYPE_UVD;
 114         case AMDGPU_HW_IP_VCE:
 115                 return AMDGPU_RING_TYPE_VCE;
 116         default:
 117                 DRM_ERROR("Invalid HW IP specified %d\n", hw_ip);
 118                 return -1;
 119         }
 120 }
 121
 122 static int amdgpu_lru_map(struct amdgpu_device *adev,
 123                           struct amdgpu_queue_mapper *mapper,
 124                           int user_ring,
 125                           struct amdgpu_ring **out_ring)
 126 {
 127         int r;
 128         int ring_type = amdgpu_hw_ip_to_ring_type(mapper->hw_ip);
 129
 130         r = amdgpu_ring_lru_get(adev, ring_type, out_ring);
 131         if (r)
 132                 return r;
 133
 134         return amdgpu_update_cached_map(mapper, user_ring, *out_ring);
 135 }
 136
 137 /**
 138  * amdgpu_queue_mgr_init - init an amdgpu_queue_mgr struct
 139  *
 140  * @adev: amdgpu_device pointer
 141  * @mgr: amdgpu_queue_mgr structure holding queue information
 142  *
 143  * Initialize the the selected @mgr (all asics).
 144  *
 145  * Returns 0 on success, error on failure.
 146  */
 147 int amdgpu_queue_mgr_init(struct amdgpu_device *adev,
 148                           struct amdgpu_queue_mgr *mgr)
 149 {
 150         int i, r;
 151
 152         if (!adev || !mgr)
 153                 return -EINVAL;
 154
 155         memset(mgr, 0, sizeof(*mgr));
 156
 157         for (i = 0; i < AMDGPU_MAX_IP_NUM; ++i) {
 158                 r = amdgpu_queue_mapper_init(&mgr->mapper[i], i);
 159                 if (r)
 160                         return r;
 161         }
 162
 163         return 0;
 164 }
 165
 166 /**
 167  * amdgpu_queue_mgr_fini - de-initialize an amdgpu_queue_mgr struct
 168  *
 169  * @adev: amdgpu_device pointer
 170  * @mgr: amdgpu_queue_mgr structure holding queue information
 171  *
 172  * De-initialize the the selected @mgr (all asics).
 173  *
 174  * Returns 0 on success, error on failure.
 175  */
 176 int amdgpu_queue_mgr_fini(struct amdgpu_device *adev,
 177                           struct amdgpu_queue_mgr *mgr)
 178 {
 179         return 0;
 180 }
 181
 182 /**
 183  * amdgpu_queue_mgr_map - Map a userspace ring id to an amdgpu_ring
 184  *
 185  * @adev: amdgpu_device pointer
 186  * @mgr: amdgpu_queue_mgr structure holding queue information
 187  * @hw_ip: HW IP enum
 188  * @instance: HW instance
 189  * @ring: user ring id
 190  * @our_ring: pointer to mapped amdgpu_ring
 191  *
 192  * Map a userspace ring id to an appropriate kernel ring. Different
 193  * policies are configurable at a HW IP level.
 194  *
 195  * Returns 0 on success, error on failure.
 196  */
 197 int amdgpu_queue_mgr_map(struct amdgpu_device *adev,
 198                          struct amdgpu_queue_mgr *mgr,
 199                          int hw_ip, int instance, int ring,
 200                          struct amdgpu_ring **out_ring)
 201 {
 202         int r, ip_num_rings;
 203         struct amdgpu_queue_mapper *mapper = &mgr->mapper[hw_ip];
 204
 205         if (!adev || !mgr || !out_ring)
 206                 return -EINVAL;
 207
 208         if (hw_ip >= AMDGPU_MAX_IP_NUM)
 209                 return -EINVAL;
 210
 211         if (ring >= AMDGPU_MAX_RINGS)
 212                 return -EINVAL;
 213
 214         /* Right now all IPs have only one instance - multiple rings. */
 215         if (instance != 0) {
 216                 DRM_ERROR("invalid ip instance: %d\n", instance);
 217                 return -EINVAL;
 218         }
 219
 220         switch (hw_ip) {
 221         case AMDGPU_HW_IP_GFX:
 222                 ip_num_rings = adev->gfx.num_gfx_rings;
 223                 break;
 224         case AMDGPU_HW_IP_COMPUTE:
 225                 ip_num_rings = adev->gfx.num_compute_rings;
 226                 break;
 227         case AMDGPU_HW_IP_DMA:
 228                 ip_num_rings = adev->sdma.num_instances;
 229                 break;
 230         case AMDGPU_HW_IP_UVD:
 231                 ip_num_rings = 1;
 232                 break;
 233         case AMDGPU_HW_IP_VCE:
 234                 ip_num_rings = adev->vce.num_rings;
 235                 break;
 236         case AMDGPU_HW_IP_UVD_ENC:
 237                 ip_num_rings = adev->uvd.num_enc_rings;
 238                 break;
 239         case AMDGPU_HW_IP_VCN_DEC:
 240                 ip_num_rings = 1;
 241                 break;
 242         case AMDGPU_HW_IP_VCN_ENC:
 243                 ip_num_rings = adev->vcn.num_enc_rings;
 244                 break;
 245         default:
 246                 DRM_ERROR("unknown ip type: %d\n", hw_ip);
 247                 return -EINVAL;
 248         }
 249
 250         if (ring >= ip_num_rings) {
 251                 DRM_ERROR("Ring index:%d exceeds maximum:%d for ip:%d\n",
 252                                 ring, ip_num_rings, hw_ip);
 253                 return -EINVAL;
 254         }
 255
 256         mutex_lock(&mapper->lock);
 257
 258         *out_ring = amdgpu_get_cached_map(mapper, ring);
 259         if (*out_ring) {
 260                 /* cache hit */
 261                 r = 0;
 262                 goto out_unlock;
 263         }
 264
 265         switch (mapper->hw_ip) {
 266         case AMDGPU_HW_IP_GFX:
 267         case AMDGPU_HW_IP_DMA:
 268         case AMDGPU_HW_IP_UVD:
 269         case AMDGPU_HW_IP_VCE:
 270         case AMDGPU_HW_IP_UVD_ENC:
 271         case AMDGPU_HW_IP_VCN_DEC:
 272         case AMDGPU_HW_IP_VCN_ENC:
 273                 r = amdgpu_identity_map(adev, mapper, ring, out_ring);
 274                 break;
 275         case AMDGPU_HW_IP_COMPUTE:
 276                 r = amdgpu_lru_map(adev, mapper, ring, out_ring);
 277                 break;
 278         default:
 279                 *out_ring = NULL;
 280                 r = -EINVAL;
 281                 DRM_ERROR("unknown HW IP type: %d\n", mapper->hw_ip);
 282         }
 283
 284 out_unlock:
 285         mutex_unlock(&mapper->lock);
 286         return r;
 287 }