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                                u32 ring,
  67                                struct amdgpu_ring **out_ring)
  68 {
  69         u32 instance;
  70
  71         switch (mapper->hw_ip) {
  72         case AMDGPU_HW_IP_GFX:
  73                 *out_ring = &adev->gfx.gfx_ring[ring];
  74                 break;
  75         case AMDGPU_HW_IP_COMPUTE:
  76                 *out_ring = &adev->gfx.compute_ring[ring];
  77                 break;
  78         case AMDGPU_HW_IP_DMA:
  79                 *out_ring = &adev->sdma.instance[ring].ring;
  80                 break;
  81         case AMDGPU_HW_IP_UVD:
  82                 instance = ring;
  83                 *out_ring = &adev->uvd.inst[instance].ring;
  84                 break;
  85         case AMDGPU_HW_IP_VCE:
  86                 *out_ring = &adev->vce.ring[ring];
  87                 break;
  88         case AMDGPU_HW_IP_UVD_ENC:
  89                 instance = ring / adev->uvd.num_enc_rings;
  90                 *out_ring =
  91                 &adev->uvd.inst[instance].ring_enc[ring%adev->uvd.num_enc_rings];
  92                 break;
  93         case AMDGPU_HW_IP_VCN_DEC:
  94                 *out_ring = &adev->vcn.ring_dec;
  95                 break;
  96         case AMDGPU_HW_IP_VCN_ENC:
  97                 *out_ring = &adev->vcn.ring_enc[ring];
  98                 break;
  99         case AMDGPU_HW_IP_VCN_JPEG:
 100                 *out_ring = &adev->vcn.ring_jpeg;
 101                 break;
 102         default:
 103                 *out_ring = NULL;
 104                 DRM_ERROR("unknown HW IP type: %d\n", mapper->hw_ip);
 105                 return -EINVAL;
 106         }
 107
 108         return amdgpu_update_cached_map(mapper, ring, *out_ring);
 109 }
 110
 111 static enum amdgpu_ring_type amdgpu_hw_ip_to_ring_type(int hw_ip)
 112 {
 113         switch (hw_ip) {
 114         case AMDGPU_HW_IP_GFX:
 115                 return AMDGPU_RING_TYPE_GFX;
 116         case AMDGPU_HW_IP_COMPUTE:
 117                 return AMDGPU_RING_TYPE_COMPUTE;
 118         case AMDGPU_HW_IP_DMA:
 119                 return AMDGPU_RING_TYPE_SDMA;
 120         case AMDGPU_HW_IP_UVD:
 121                 return AMDGPU_RING_TYPE_UVD;
 122         case AMDGPU_HW_IP_VCE:
 123                 return AMDGPU_RING_TYPE_VCE;
 124         default:
 125                 DRM_ERROR("Invalid HW IP specified %d\n", hw_ip);
 126                 return -1;
 127         }
 128 }
 129
 130 static int amdgpu_lru_map(struct amdgpu_device *adev,
 131                           struct amdgpu_queue_mapper *mapper,
 132                           u32 user_ring, bool lru_pipe_order,
 133                           struct amdgpu_ring **out_ring)
 134 {
 135         int r, i, j;
 136         int ring_type = amdgpu_hw_ip_to_ring_type(mapper->hw_ip);
 137         int ring_blacklist[AMDGPU_MAX_RINGS];
 138         struct amdgpu_ring *ring;
 139
 140         /* 0 is a valid ring index, so initialize to -1 */
 141         memset(ring_blacklist, 0xff, sizeof(ring_blacklist));
 142
 143         for (i = 0, j = 0; i < AMDGPU_MAX_RINGS; i++) {
 144                 ring = mapper->queue_map[i];
 145                 if (ring)
 146                         ring_blacklist[j++] = ring->idx;
 147         }
 148
 149         r = amdgpu_ring_lru_get(adev, ring_type, ring_blacklist,
 150                                 j, lru_pipe_order, out_ring);
 151         if (r)
 152                 return r;
 153
 154         return amdgpu_update_cached_map(mapper, user_ring, *out_ring);
 155 }
 156
 157 /**
 158  * amdgpu_queue_mgr_init - init an amdgpu_queue_mgr struct
 159  *
 160  * @adev: amdgpu_device pointer
 161  * @mgr: amdgpu_queue_mgr structure holding queue information
 162  *
 163  * Initialize the the selected @mgr (all asics).
 164  *
 165  * Returns 0 on success, error on failure.
 166  */
 167 int amdgpu_queue_mgr_init(struct amdgpu_device *adev,
 168                           struct amdgpu_queue_mgr *mgr)
 169 {
 170         int i, r;
 171
 172         if (!adev || !mgr)
 173                 return -EINVAL;
 174
 175         memset(mgr, 0, sizeof(*mgr));
 176
 177         for (i = 0; i < AMDGPU_MAX_IP_NUM; ++i) {
 178                 r = amdgpu_queue_mapper_init(&mgr->mapper[i], i);
 179                 if (r)
 180                         return r;
 181         }
 182
 183         return 0;
 184 }
 185
 186 /**
 187  * amdgpu_queue_mgr_fini - de-initialize an amdgpu_queue_mgr struct
 188  *
 189  * @adev: amdgpu_device pointer
 190  * @mgr: amdgpu_queue_mgr structure holding queue information
 191  *
 192  * De-initialize the the selected @mgr (all asics).
 193  *
 194  * Returns 0 on success, error on failure.
 195  */
 196 int amdgpu_queue_mgr_fini(struct amdgpu_device *adev,
 197                           struct amdgpu_queue_mgr *mgr)
 198 {
 199         return 0;
 200 }
 201
 202 /**
 203  * amdgpu_queue_mgr_map - Map a userspace ring id to an amdgpu_ring
 204  *
 205  * @adev: amdgpu_device pointer
 206  * @mgr: amdgpu_queue_mgr structure holding queue information
 207  * @hw_ip: HW IP enum
 208  * @instance: HW instance
 209  * @ring: user ring id
 210  * @our_ring: pointer to mapped amdgpu_ring
 211  *
 212  * Map a userspace ring id to an appropriate kernel ring. Different
 213  * policies are configurable at a HW IP level.
 214  *
 215  * Returns 0 on success, error on failure.
 216  */
 217 int amdgpu_queue_mgr_map(struct amdgpu_device *adev,
 218                          struct amdgpu_queue_mgr *mgr,
 219                          u32 hw_ip, u32 instance, u32 ring,
 220                          struct amdgpu_ring **out_ring)
 221 {
 222         int r, ip_num_rings;
 223         struct amdgpu_queue_mapper *mapper = &mgr->mapper[hw_ip];
 224
 225         if (!adev || !mgr || !out_ring)
 226                 return -EINVAL;
 227
 228         if (hw_ip >= AMDGPU_MAX_IP_NUM)
 229                 return -EINVAL;
 230
 231         if (ring >= AMDGPU_MAX_RINGS)
 232                 return -EINVAL;
 233
 234         /* Right now all IPs have only one instance - multiple rings. */
 235         if (instance != 0) {
 236                 DRM_DEBUG("invalid ip instance: %d\n", instance);
 237                 return -EINVAL;
 238         }
 239
 240         switch (hw_ip) {
 241         case AMDGPU_HW_IP_GFX:
 242                 ip_num_rings = adev->gfx.num_gfx_rings;
 243                 break;
 244         case AMDGPU_HW_IP_COMPUTE:
 245                 ip_num_rings = adev->gfx.num_compute_rings;
 246                 break;
 247         case AMDGPU_HW_IP_DMA:
 248                 ip_num_rings = adev->sdma.num_instances;
 249                 break;
 250         case AMDGPU_HW_IP_UVD:
 251                 ip_num_rings = adev->uvd.num_uvd_inst;
 252                 break;
 253         case AMDGPU_HW_IP_VCE:
 254                 ip_num_rings = adev->vce.num_rings;
 255                 break;
 256         case AMDGPU_HW_IP_UVD_ENC:
 257                 ip_num_rings =
 258                         adev->uvd.num_enc_rings * adev->uvd.num_uvd_inst;
 259                 break;
 260         case AMDGPU_HW_IP_VCN_DEC:
 261                 ip_num_rings = 1;
 262                 break;
 263         case AMDGPU_HW_IP_VCN_ENC:
 264                 ip_num_rings = adev->vcn.num_enc_rings;
 265                 break;
 266         case AMDGPU_HW_IP_VCN_JPEG:
 267                 ip_num_rings = 1;
 268                 break;
 269         default:
 270                 DRM_DEBUG("unknown ip type: %d\n", hw_ip);
 271                 return -EINVAL;
 272         }
 273
 274         if (ring >= ip_num_rings) {
 275                 DRM_DEBUG("Ring index:%d exceeds maximum:%d for ip:%d\n",
 276                           ring, ip_num_rings, hw_ip);
 277                 return -EINVAL;
 278         }
 279
 280         mutex_lock(&mapper->lock);
 281
 282         *out_ring = amdgpu_get_cached_map(mapper, ring);
 283         if (*out_ring) {
 284                 /* cache hit */
 285                 r = 0;
 286                 goto out_unlock;
 287         }
 288
 289         switch (mapper->hw_ip) {
 290         case AMDGPU_HW_IP_GFX:
 291         case AMDGPU_HW_IP_UVD:
 292         case AMDGPU_HW_IP_VCE:
 293         case AMDGPU_HW_IP_UVD_ENC:
 294         case AMDGPU_HW_IP_VCN_DEC:
 295         case AMDGPU_HW_IP_VCN_ENC:
 296         case AMDGPU_HW_IP_VCN_JPEG:
 297                 r = amdgpu_identity_map(adev, mapper, ring, out_ring);
 298                 break;
 299         case AMDGPU_HW_IP_DMA:
 300                 r = amdgpu_lru_map(adev, mapper, ring, false, out_ring);
 301                 break;
 302         case AMDGPU_HW_IP_COMPUTE:
 303                 r = amdgpu_lru_map(adev, mapper, ring, true, out_ring);
 304                 break;
 305         default:
 306                 *out_ring = NULL;
 307                 r = -EINVAL;
 308                 DRM_DEBUG("unknown HW IP type: %d\n", mapper->hw_ip);
 309         }
 310
 311 out_unlock:
 312         mutex_unlock(&mapper->lock);
 313         return r;
 314 }