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

   1 /*
   2  * Copyright 2014 Advanced Micro Devices, Inc.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sub license, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  16  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  17  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  18  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  19  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  20  *
  21  * The above copyright notice and this permission notice (including the
  22  * next paragraph) shall be included in all copies or substantial portions
  23  * of the Software.
  24  *
  25  * Authors: Christian König <christian.koenig@amd.com>
  26  */
  27
  28 #include <linux/firmware.h>
  29 #include <drm/drmP.h>
  30 #include "amdgpu.h"
  31 #include "amdgpu_vce.h"
  32 #include "vid.h"
  33 #include "vce/vce_3_0_d.h"
  34 #include "vce/vce_3_0_sh_mask.h"
  35 #include "oss/oss_3_0_d.h"
  36 #include "oss/oss_3_0_sh_mask.h"
  37 #include "gca/gfx_8_0_d.h"
  38 #include "smu/smu_7_1_2_d.h"
  39 #include "smu/smu_7_1_2_sh_mask.h"
  40 #include "gca/gfx_8_0_d.h"
  41 #include "gca/gfx_8_0_sh_mask.h"
  42
  43
  44 #define GRBM_GFX_INDEX__VCE_INSTANCE__SHIFT     0x04
  45 #define GRBM_GFX_INDEX__VCE_INSTANCE_MASK       0x10
  46 #define mmVCE_LMI_VCPU_CACHE_40BIT_BAR0 0x8616
  47 #define mmVCE_LMI_VCPU_CACHE_40BIT_BAR1 0x8617
  48 #define mmVCE_LMI_VCPU_CACHE_40BIT_BAR2 0x8618
  49 #define VCE_STATUS_VCPU_REPORT_FW_LOADED_MASK   0x02
  50
  51 #define VCE_V3_0_FW_SIZE        (384 * 1024)
  52 #define VCE_V3_0_STACK_SIZE     (64 * 1024)
  53 #define VCE_V3_0_DATA_SIZE      ((16 * 1024 * AMDGPU_MAX_VCE_HANDLES) + (52 * 1024))
  54
  55 static void vce_v3_0_mc_resume(struct amdgpu_device *adev, int idx);
  56 static void vce_v3_0_set_ring_funcs(struct amdgpu_device *adev);
  57 static void vce_v3_0_set_irq_funcs(struct amdgpu_device *adev);
  58 static int vce_v3_0_wait_for_idle(void *handle);
  59
  60 /**
  61  * vce_v3_0_ring_get_rptr - get read pointer
  62  *
  63  * @ring: amdgpu_ring pointer
  64  *
  65  * Returns the current hardware read pointer
  66  */
  67 static uint32_t vce_v3_0_ring_get_rptr(struct amdgpu_ring *ring)
  68 {
  69         struct amdgpu_device *adev = ring->adev;
  70
  71         if (ring == &adev->vce.ring[0])
  72                 return RREG32(mmVCE_RB_RPTR);
  73         else
  74                 return RREG32(mmVCE_RB_RPTR2);
  75 }
  76
  77 /**
  78  * vce_v3_0_ring_get_wptr - get write pointer
  79  *
  80  * @ring: amdgpu_ring pointer
  81  *
  82  * Returns the current hardware write pointer
  83  */
  84 static uint32_t vce_v3_0_ring_get_wptr(struct amdgpu_ring *ring)
  85 {
  86         struct amdgpu_device *adev = ring->adev;
  87
  88         if (ring == &adev->vce.ring[0])
  89                 return RREG32(mmVCE_RB_WPTR);
  90         else
  91                 return RREG32(mmVCE_RB_WPTR2);
  92 }
  93
  94 /**
  95  * vce_v3_0_ring_set_wptr - set write pointer
  96  *
  97  * @ring: amdgpu_ring pointer
  98  *
  99  * Commits the write pointer to the hardware
 100  */
 101 static void vce_v3_0_ring_set_wptr(struct amdgpu_ring *ring)
 102 {
 103         struct amdgpu_device *adev = ring->adev;
 104
 105         if (ring == &adev->vce.ring[0])
 106                 WREG32(mmVCE_RB_WPTR, ring->wptr);
 107         else
 108                 WREG32(mmVCE_RB_WPTR2, ring->wptr);
 109 }
 110
 111 static void vce_v3_0_override_vce_clock_gating(struct amdgpu_device *adev, bool override)
 112 {
 113         WREG32_FIELD(VCE_RB_ARB_CTRL, VCE_CGTT_OVERRIDE, override ? 1 : 0);
 114 }
 115
 116 static void vce_v3_0_set_vce_sw_clock_gating(struct amdgpu_device *adev,
 117                                              bool gated)
 118 {
 119         u32 data;
 120
 121         /* Set Override to disable Clock Gating */
 122         vce_v3_0_override_vce_clock_gating(adev, true);
 123
 124         /* This function enables MGCG which is controlled by firmware.
 125            With the clocks in the gated state the core is still
 126            accessible but the firmware will throttle the clocks on the
 127            fly as necessary.
 128         */
 129         if (gated) {
 130                 data = RREG32(mmVCE_CLOCK_GATING_B);
 131                 data |= 0x1ff;
 132                 data &= ~0xef0000;
 133                 WREG32(mmVCE_CLOCK_GATING_B, data);
 134
 135                 data = RREG32(mmVCE_UENC_CLOCK_GATING);
 136                 data |= 0x3ff000;
 137                 data &= ~0xffc00000;
 138                 WREG32(mmVCE_UENC_CLOCK_GATING, data);
 139
 140                 data = RREG32(mmVCE_UENC_CLOCK_GATING_2);
 141                 data |= 0x2;
 142                 data &= ~0x00010000;
 143                 WREG32(mmVCE_UENC_CLOCK_GATING_2, data);
 144
 145                 data = RREG32(mmVCE_UENC_REG_CLOCK_GATING);
 146                 data |= 0x37f;
 147                 WREG32(mmVCE_UENC_REG_CLOCK_GATING, data);
 148
 149                 data = RREG32(mmVCE_UENC_DMA_DCLK_CTRL);
 150                 data |= VCE_UENC_DMA_DCLK_CTRL__WRDMCLK_FORCEON_MASK |
 151                         VCE_UENC_DMA_DCLK_CTRL__RDDMCLK_FORCEON_MASK |
 152                         VCE_UENC_DMA_DCLK_CTRL__REGCLK_FORCEON_MASK  |
 153                         0x8;
 154                 WREG32(mmVCE_UENC_DMA_DCLK_CTRL, data);
 155         } else {
 156                 data = RREG32(mmVCE_CLOCK_GATING_B);
 157                 data &= ~0x80010;
 158                 data |= 0xe70008;
 159                 WREG32(mmVCE_CLOCK_GATING_B, data);
 160
 161                 data = RREG32(mmVCE_UENC_CLOCK_GATING);
 162                 data |= 0xffc00000;
 163                 WREG32(mmVCE_UENC_CLOCK_GATING, data);
 164
 165                 data = RREG32(mmVCE_UENC_CLOCK_GATING_2);
 166                 data |= 0x10000;
 167                 WREG32(mmVCE_UENC_CLOCK_GATING_2, data);
 168
 169                 data = RREG32(mmVCE_UENC_REG_CLOCK_GATING);
 170                 data &= ~0xffc00000;
 171                 WREG32(mmVCE_UENC_REG_CLOCK_GATING, data);
 172
 173                 data = RREG32(mmVCE_UENC_DMA_DCLK_CTRL);
 174                 data &= ~(VCE_UENC_DMA_DCLK_CTRL__WRDMCLK_FORCEON_MASK |
 175                           VCE_UENC_DMA_DCLK_CTRL__RDDMCLK_FORCEON_MASK |
 176                           VCE_UENC_DMA_DCLK_CTRL__REGCLK_FORCEON_MASK  |
 177                           0x8);
 178                 WREG32(mmVCE_UENC_DMA_DCLK_CTRL, data);
 179         }
 180         vce_v3_0_override_vce_clock_gating(adev, false);
 181 }
 182
 183 static int vce_v3_0_firmware_loaded(struct amdgpu_device *adev)
 184 {
 185         int i, j;
 186
 187         for (i = 0; i < 10; ++i) {
 188                 for (j = 0; j < 100; ++j) {
 189                         uint32_t status = RREG32(mmVCE_STATUS);
 190
 191                         if (status & VCE_STATUS_VCPU_REPORT_FW_LOADED_MASK)
 192                                 return 0;
 193                         mdelay(10);
 194                 }
 195
 196                 DRM_ERROR("VCE not responding, trying to reset the ECPU!!!\n");
 197                 WREG32_FIELD(VCE_SOFT_RESET, ECPU_SOFT_RESET, 1);
 198                 mdelay(10);
 199                 WREG32_FIELD(VCE_SOFT_RESET, ECPU_SOFT_RESET, 0);
 200                 mdelay(10);
 201         }
 202
 203         return -ETIMEDOUT;
 204 }
 205
 206 /**
 207  * vce_v3_0_start - start VCE block
 208  *
 209  * @adev: amdgpu_device pointer
 210  *
 211  * Setup and start the VCE block
 212  */
 213 static int vce_v3_0_start(struct amdgpu_device *adev)
 214 {
 215         struct amdgpu_ring *ring;
 216         int idx, r;
 217
 218         ring = &adev->vce.ring[0];
 219         WREG32(mmVCE_RB_RPTR, ring->wptr);
 220         WREG32(mmVCE_RB_WPTR, ring->wptr);
 221         WREG32(mmVCE_RB_BASE_LO, ring->gpu_addr);
 222         WREG32(mmVCE_RB_BASE_HI, upper_32_bits(ring->gpu_addr));
 223         WREG32(mmVCE_RB_SIZE, ring->ring_size / 4);
 224
 225         ring = &adev->vce.ring[1];
 226         WREG32(mmVCE_RB_RPTR2, ring->wptr);
 227         WREG32(mmVCE_RB_WPTR2, ring->wptr);
 228         WREG32(mmVCE_RB_BASE_LO2, ring->gpu_addr);
 229         WREG32(mmVCE_RB_BASE_HI2, upper_32_bits(ring->gpu_addr));
 230         WREG32(mmVCE_RB_SIZE2, ring->ring_size / 4);
 231
 232         mutex_lock(&adev->grbm_idx_mutex);
 233         for (idx = 0; idx < 2; ++idx) {
 234                 if (adev->vce.harvest_config & (1 << idx))
 235                         continue;
 236
 237                 WREG32_FIELD(GRBM_GFX_INDEX, VCE_INSTANCE, idx);
 238                 vce_v3_0_mc_resume(adev, idx);
 239                 WREG32_FIELD(VCE_STATUS, JOB_BUSY, 1);
 240
 241                 if (adev->asic_type >= CHIP_STONEY)
 242                         WREG32_P(mmVCE_VCPU_CNTL, 1, ~0x200001);
 243                 else
 244                         WREG32_FIELD(VCE_VCPU_CNTL, CLK_EN, 1);
 245
 246                 WREG32_FIELD(VCE_SOFT_RESET, ECPU_SOFT_RESET, 0);
 247                 mdelay(100);
 248
 249                 r = vce_v3_0_firmware_loaded(adev);
 250
 251                 /* clear BUSY flag */
 252                 WREG32_FIELD(VCE_STATUS, JOB_BUSY, 0);
 253
 254                 if (r) {
 255                         DRM_ERROR("VCE not responding, giving up!!!\n");
 256                         mutex_unlock(&adev->grbm_idx_mutex);
 257                         return r;
 258                 }
 259         }
 260
 261         WREG32_FIELD(GRBM_GFX_INDEX, VCE_INSTANCE, 0);
 262         mutex_unlock(&adev->grbm_idx_mutex);
 263
 264         return 0;
 265 }
 266
 267 static int vce_v3_0_stop(struct amdgpu_device *adev)
 268 {
 269         int idx;
 270
 271         mutex_lock(&adev->grbm_idx_mutex);
 272         for (idx = 0; idx < 2; ++idx) {
 273                 if (adev->vce.harvest_config & (1 << idx))
 274                         continue;
 275
 276                 WREG32_FIELD(GRBM_GFX_INDEX, VCE_INSTANCE, idx);
 277
 278                 if (adev->asic_type >= CHIP_STONEY)
 279                         WREG32_P(mmVCE_VCPU_CNTL, 0, ~0x200001);
 280                 else
 281                         WREG32_FIELD(VCE_VCPU_CNTL, CLK_EN, 0);
 282
 283                 /* hold on ECPU */
 284                 WREG32_FIELD(VCE_SOFT_RESET, ECPU_SOFT_RESET, 1);
 285
 286                 /* clear BUSY flag */
 287                 WREG32_FIELD(VCE_STATUS, JOB_BUSY, 0);
 288
 289                 /* Set Clock-Gating off */
 290                 if (adev->cg_flags & AMD_CG_SUPPORT_VCE_MGCG)
 291                         vce_v3_0_set_vce_sw_clock_gating(adev, false);
 292         }
 293
 294         WREG32_FIELD(GRBM_GFX_INDEX, VCE_INSTANCE, 0);
 295         mutex_unlock(&adev->grbm_idx_mutex);
 296
 297         return 0;
 298 }
 299
 300 #define ixVCE_HARVEST_FUSE_MACRO__ADDRESS     0xC0014074
 301 #define VCE_HARVEST_FUSE_MACRO__SHIFT       27
 302 #define VCE_HARVEST_FUSE_MACRO__MASK        0x18000000
 303
 304 static unsigned vce_v3_0_get_harvest_config(struct amdgpu_device *adev)
 305 {
 306         u32 tmp;
 307
 308         /* Fiji, Stoney, Polaris10, Polaris11 are single pipe */
 309         if ((adev->asic_type == CHIP_FIJI) ||
 310             (adev->asic_type == CHIP_STONEY) ||
 311             (adev->asic_type == CHIP_POLARIS10) ||
 312             (adev->asic_type == CHIP_POLARIS11))
 313                 return AMDGPU_VCE_HARVEST_VCE1;
 314
 315         /* Tonga and CZ are dual or single pipe */
 316         if (adev->flags & AMD_IS_APU)
 317                 tmp = (RREG32_SMC(ixVCE_HARVEST_FUSE_MACRO__ADDRESS) &
 318                        VCE_HARVEST_FUSE_MACRO__MASK) >>
 319                         VCE_HARVEST_FUSE_MACRO__SHIFT;
 320         else
 321                 tmp = (RREG32_SMC(ixCC_HARVEST_FUSES) &
 322                        CC_HARVEST_FUSES__VCE_DISABLE_MASK) >>
 323                         CC_HARVEST_FUSES__VCE_DISABLE__SHIFT;
 324
 325         switch (tmp) {
 326         case 1:
 327                 return AMDGPU_VCE_HARVEST_VCE0;
 328         case 2:
 329                 return AMDGPU_VCE_HARVEST_VCE1;
 330         case 3:
 331                 return AMDGPU_VCE_HARVEST_VCE0 | AMDGPU_VCE_HARVEST_VCE1;
 332         default:
 333                 return 0;
 334         }
 335 }
 336
 337 static int vce_v3_0_early_init(void *handle)
 338 {
 339         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 340
 341         adev->vce.harvest_config = vce_v3_0_get_harvest_config(adev);
 342
 343         if ((adev->vce.harvest_config &
 344              (AMDGPU_VCE_HARVEST_VCE0 | AMDGPU_VCE_HARVEST_VCE1)) ==
 345             (AMDGPU_VCE_HARVEST_VCE0 | AMDGPU_VCE_HARVEST_VCE1))
 346                 return -ENOENT;
 347
 348         vce_v3_0_set_ring_funcs(adev);
 349         vce_v3_0_set_irq_funcs(adev);
 350
 351         return 0;
 352 }
 353
 354 static int vce_v3_0_sw_init(void *handle)
 355 {
 356         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 357         struct amdgpu_ring *ring;
 358         int r;
 359
 360         /* VCE */
 361         r = amdgpu_irq_add_id(adev, 167, &adev->vce.irq);
 362         if (r)
 363                 return r;
 364
 365         r = amdgpu_vce_sw_init(adev, VCE_V3_0_FW_SIZE +
 366                 (VCE_V3_0_STACK_SIZE + VCE_V3_0_DATA_SIZE) * 2);
 367         if (r)
 368                 return r;
 369
 370         r = amdgpu_vce_resume(adev);
 371         if (r)
 372                 return r;
 373
 374         ring = &adev->vce.ring[0];
 375         sprintf(ring->name, "vce0");
 376         r = amdgpu_ring_init(adev, ring, 512, VCE_CMD_NO_OP, 0xf,
 377                              &adev->vce.irq, 0, AMDGPU_RING_TYPE_VCE);
 378         if (r)
 379                 return r;
 380
 381         ring = &adev->vce.ring[1];
 382         sprintf(ring->name, "vce1");
 383         r = amdgpu_ring_init(adev, ring, 512, VCE_CMD_NO_OP, 0xf,
 384                              &adev->vce.irq, 0, AMDGPU_RING_TYPE_VCE);
 385         if (r)
 386                 return r;
 387
 388         return r;
 389 }
 390
 391 static int vce_v3_0_sw_fini(void *handle)
 392 {
 393         int r;
 394         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 395
 396         r = amdgpu_vce_suspend(adev);
 397         if (r)
 398                 return r;
 399
 400         r = amdgpu_vce_sw_fini(adev);
 401         if (r)
 402                 return r;
 403
 404         return r;
 405 }
 406
 407 static int vce_v3_0_hw_init(void *handle)
 408 {
 409         int r, i;
 410         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 411
 412         r = vce_v3_0_start(adev);
 413         if (r)
 414                 return r;
 415
 416         adev->vce.ring[0].ready = false;
 417         adev->vce.ring[1].ready = false;
 418
 419         for (i = 0; i < 2; i++) {
 420                 r = amdgpu_ring_test_ring(&adev->vce.ring[i]);
 421                 if (r)
 422                         return r;
 423                 else
 424                         adev->vce.ring[i].ready = true;
 425         }
 426
 427         DRM_INFO("VCE initialized successfully.\n");
 428
 429         return 0;
 430 }
 431
 432 static int vce_v3_0_hw_fini(void *handle)
 433 {
 434         int r;
 435         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 436
 437         r = vce_v3_0_wait_for_idle(handle);
 438         if (r)
 439                 return r;
 440
 441         return vce_v3_0_stop(adev);
 442 }
 443
 444 static int vce_v3_0_suspend(void *handle)
 445 {
 446         int r;
 447         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 448
 449         r = vce_v3_0_hw_fini(adev);
 450         if (r)
 451                 return r;
 452
 453         r = amdgpu_vce_suspend(adev);
 454         if (r)
 455                 return r;
 456
 457         return r;
 458 }
 459
 460 static int vce_v3_0_resume(void *handle)
 461 {
 462         int r;
 463         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 464
 465         r = amdgpu_vce_resume(adev);
 466         if (r)
 467                 return r;
 468
 469         r = vce_v3_0_hw_init(adev);
 470         if (r)
 471                 return r;
 472
 473         return r;
 474 }
 475
 476 static void vce_v3_0_mc_resume(struct amdgpu_device *adev, int idx)
 477 {
 478         uint32_t offset, size;
 479
 480         WREG32_P(mmVCE_CLOCK_GATING_A, 0, ~(1 << 16));
 481         WREG32_P(mmVCE_UENC_CLOCK_GATING, 0x1FF000, ~0xFF9FF000);
 482         WREG32_P(mmVCE_UENC_REG_CLOCK_GATING, 0x3F, ~0x3F);
 483         WREG32(mmVCE_CLOCK_GATING_B, 0x1FF);
 484
 485         WREG32(mmVCE_LMI_CTRL, 0x00398000);
 486         WREG32_P(mmVCE_LMI_CACHE_CTRL, 0x0, ~0x1);
 487         WREG32(mmVCE_LMI_SWAP_CNTL, 0);
 488         WREG32(mmVCE_LMI_SWAP_CNTL1, 0);
 489         WREG32(mmVCE_LMI_VM_CTRL, 0);
 490         if (adev->asic_type >= CHIP_STONEY) {
 491                 WREG32(mmVCE_LMI_VCPU_CACHE_40BIT_BAR0, (adev->vce.gpu_addr >> 8));
 492                 WREG32(mmVCE_LMI_VCPU_CACHE_40BIT_BAR1, (adev->vce.gpu_addr >> 8));
 493                 WREG32(mmVCE_LMI_VCPU_CACHE_40BIT_BAR2, (adev->vce.gpu_addr >> 8));
 494         } else
 495                 WREG32(mmVCE_LMI_VCPU_CACHE_40BIT_BAR, (adev->vce.gpu_addr >> 8));
 496         offset = AMDGPU_VCE_FIRMWARE_OFFSET;
 497         size = VCE_V3_0_FW_SIZE;
 498         WREG32(mmVCE_VCPU_CACHE_OFFSET0, offset & 0x7fffffff);
 499         WREG32(mmVCE_VCPU_CACHE_SIZE0, size);
 500
 501         if (idx == 0) {
 502                 offset += size;
 503                 size = VCE_V3_0_STACK_SIZE;
 504                 WREG32(mmVCE_VCPU_CACHE_OFFSET1, offset & 0x7fffffff);
 505                 WREG32(mmVCE_VCPU_CACHE_SIZE1, size);
 506                 offset += size;
 507                 size = VCE_V3_0_DATA_SIZE;
 508                 WREG32(mmVCE_VCPU_CACHE_OFFSET2, offset & 0x7fffffff);
 509                 WREG32(mmVCE_VCPU_CACHE_SIZE2, size);
 510         } else {
 511                 offset += size + VCE_V3_0_STACK_SIZE + VCE_V3_0_DATA_SIZE;
 512                 size = VCE_V3_0_STACK_SIZE;
 513                 WREG32(mmVCE_VCPU_CACHE_OFFSET1, offset & 0xfffffff);
 514                 WREG32(mmVCE_VCPU_CACHE_SIZE1, size);
 515                 offset += size;
 516                 size = VCE_V3_0_DATA_SIZE;
 517                 WREG32(mmVCE_VCPU_CACHE_OFFSET2, offset & 0xfffffff);
 518                 WREG32(mmVCE_VCPU_CACHE_SIZE2, size);
 519         }
 520
 521         WREG32_P(mmVCE_LMI_CTRL2, 0x0, ~0x100);
 522         WREG32_FIELD(VCE_SYS_INT_EN, VCE_SYS_INT_TRAP_INTERRUPT_EN, 1);
 523 }
 524
 525 static bool vce_v3_0_is_idle(void *handle)
 526 {
 527         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 528         u32 mask = 0;
 529
 530         mask |= (adev->vce.harvest_config & AMDGPU_VCE_HARVEST_VCE0) ? 0 : SRBM_STATUS2__VCE0_BUSY_MASK;
 531         mask |= (adev->vce.harvest_config & AMDGPU_VCE_HARVEST_VCE1) ? 0 : SRBM_STATUS2__VCE1_BUSY_MASK;
 532
 533         return !(RREG32(mmSRBM_STATUS2) & mask);
 534 }
 535
 536 static int vce_v3_0_wait_for_idle(void *handle)
 537 {
 538         unsigned i;
 539         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 540
 541         for (i = 0; i < adev->usec_timeout; i++)
 542                 if (vce_v3_0_is_idle(handle))
 543                         return 0;
 544
 545         return -ETIMEDOUT;
 546 }
 547
 548 #define  VCE_STATUS_VCPU_REPORT_AUTO_BUSY_MASK  0x00000008L   /* AUTO_BUSY */
 549 #define  VCE_STATUS_VCPU_REPORT_RB0_BUSY_MASK   0x00000010L   /* RB0_BUSY */
 550 #define  VCE_STATUS_VCPU_REPORT_RB1_BUSY_MASK   0x00000020L   /* RB1_BUSY */
 551 #define  AMDGPU_VCE_STATUS_BUSY_MASK (VCE_STATUS_VCPU_REPORT_AUTO_BUSY_MASK | \
 552                                       VCE_STATUS_VCPU_REPORT_RB0_BUSY_MASK)
 553
 554 static int vce_v3_0_check_soft_reset(void *handle)
 555 {
 556         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 557         u32 srbm_soft_reset = 0;
 558
 559         /* According to VCE team , we should use VCE_STATUS instead
 560          * SRBM_STATUS.VCE_BUSY bit for busy status checking.
 561          * GRBM_GFX_INDEX.INSTANCE_INDEX is used to specify which VCE
 562          * instance's registers are accessed
 563          * (0 for 1st instance, 10 for 2nd instance).
 564          *
 565          *VCE_STATUS
 566          *|UENC|ACPI|AUTO ACTIVE|RB1 |RB0 |RB2 |          |FW_LOADED|JOB |
 567          *|----+----+-----------+----+----+----+----------+---------+----|
 568          *|bit8|bit7|    bit6   |bit5|bit4|bit3|   bit2   |  bit1   |bit0|
 569          *
 570          * VCE team suggest use bit 3--bit 6 for busy status check
 571          */
 572         mutex_lock(&adev->grbm_idx_mutex);
 573         WREG32_FIELD(GRBM_GFX_INDEX, INSTANCE_INDEX, 0);
 574         if (RREG32(mmVCE_STATUS) & AMDGPU_VCE_STATUS_BUSY_MASK) {
 575                 srbm_soft_reset = REG_SET_FIELD(srbm_soft_reset, SRBM_SOFT_RESET, SOFT_RESET_VCE0, 1);
 576                 srbm_soft_reset = REG_SET_FIELD(srbm_soft_reset, SRBM_SOFT_RESET, SOFT_RESET_VCE1, 1);
 577         }
 578         WREG32_FIELD(GRBM_GFX_INDEX, INSTANCE_INDEX, 0x10);
 579         if (RREG32(mmVCE_STATUS) & AMDGPU_VCE_STATUS_BUSY_MASK) {
 580                 srbm_soft_reset = REG_SET_FIELD(srbm_soft_reset, SRBM_SOFT_RESET, SOFT_RESET_VCE0, 1);
 581                 srbm_soft_reset = REG_SET_FIELD(srbm_soft_reset, SRBM_SOFT_RESET, SOFT_RESET_VCE1, 1);
 582         }
 583         WREG32_FIELD(GRBM_GFX_INDEX, INSTANCE_INDEX, 0);
 584
 585         if (srbm_soft_reset) {
 586                 adev->ip_block_status[AMD_IP_BLOCK_TYPE_VCE].hang = true;
 587                 adev->vce.srbm_soft_reset = srbm_soft_reset;
 588         } else {
 589                 adev->ip_block_status[AMD_IP_BLOCK_TYPE_VCE].hang = false;
 590                 adev->vce.srbm_soft_reset = 0;
 591         }
 592         mutex_unlock(&adev->grbm_idx_mutex);
 593         return 0;
 594 }
 595
 596 static int vce_v3_0_soft_reset(void *handle)
 597 {
 598         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 599         u32 srbm_soft_reset;
 600
 601         if (!adev->ip_block_status[AMD_IP_BLOCK_TYPE_VCE].hang)
 602                 return 0;
 603         srbm_soft_reset = adev->vce.srbm_soft_reset;
 604
 605         if (srbm_soft_reset) {
 606                 u32 tmp;
 607
 608                 tmp = RREG32(mmSRBM_SOFT_RESET);
 609                 tmp |= srbm_soft_reset;
 610                 dev_info(adev->dev, "SRBM_SOFT_RESET=0x%08X\n", tmp);
 611                 WREG32(mmSRBM_SOFT_RESET, tmp);
 612                 tmp = RREG32(mmSRBM_SOFT_RESET);
 613
 614                 udelay(50);
 615
 616                 tmp &= ~srbm_soft_reset;
 617                 WREG32(mmSRBM_SOFT_RESET, tmp);
 618                 tmp = RREG32(mmSRBM_SOFT_RESET);
 619
 620                 /* Wait a little for things to settle down */
 621                 udelay(50);
 622         }
 623
 624         return 0;
 625 }
 626
 627 static int vce_v3_0_pre_soft_reset(void *handle)
 628 {
 629         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 630
 631         if (!adev->ip_block_status[AMD_IP_BLOCK_TYPE_VCE].hang)
 632                 return 0;
 633
 634         mdelay(5);
 635
 636         return vce_v3_0_suspend(adev);
 637 }
 638
 639
 640 static int vce_v3_0_post_soft_reset(void *handle)
 641 {
 642         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 643
 644         if (!adev->ip_block_status[AMD_IP_BLOCK_TYPE_VCE].hang)
 645                 return 0;
 646
 647         mdelay(5);
 648
 649         return vce_v3_0_resume(adev);
 650 }
 651
 652 static int vce_v3_0_set_interrupt_state(struct amdgpu_device *adev,
 653                                         struct amdgpu_irq_src *source,
 654                                         unsigned type,
 655                                         enum amdgpu_interrupt_state state)
 656 {
 657         uint32_t val = 0;
 658
 659         if (state == AMDGPU_IRQ_STATE_ENABLE)
 660                 val |= VCE_SYS_INT_EN__VCE_SYS_INT_TRAP_INTERRUPT_EN_MASK;
 661
 662         WREG32_P(mmVCE_SYS_INT_EN, val, ~VCE_SYS_INT_EN__VCE_SYS_INT_TRAP_INTERRUPT_EN_MASK);
 663         return 0;
 664 }
 665
 666 static int vce_v3_0_process_interrupt(struct amdgpu_device *adev,
 667                                       struct amdgpu_irq_src *source,
 668                                       struct amdgpu_iv_entry *entry)
 669 {
 670         DRM_DEBUG("IH: VCE\n");
 671
 672         WREG32_FIELD(VCE_SYS_INT_STATUS, VCE_SYS_INT_TRAP_INTERRUPT_INT, 1);
 673
 674         switch (entry->src_data) {
 675         case 0:
 676         case 1:
 677                 amdgpu_fence_process(&adev->vce.ring[entry->src_data]);
 678                 break;
 679         default:
 680                 DRM_ERROR("Unhandled interrupt: %d %d\n",
 681                           entry->src_id, entry->src_data);
 682                 break;
 683         }
 684
 685         return 0;
 686 }
 687
 688 static void vce_v3_set_bypass_mode(struct amdgpu_device *adev, bool enable)
 689 {
 690         u32 tmp = RREG32_SMC(ixGCK_DFS_BYPASS_CNTL);
 691
 692         if (enable)
 693                 tmp |= GCK_DFS_BYPASS_CNTL__BYPASSECLK_MASK;
 694         else
 695                 tmp &= ~GCK_DFS_BYPASS_CNTL__BYPASSECLK_MASK;
 696
 697         WREG32_SMC(ixGCK_DFS_BYPASS_CNTL, tmp);
 698 }
 699
 700 static int vce_v3_0_set_clockgating_state(void *handle,
 701                                           enum amd_clockgating_state state)
 702 {
 703         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 704         bool enable = (state == AMD_CG_STATE_GATE) ? true : false;
 705         int i;
 706
 707         if (adev->asic_type == CHIP_POLARIS10)
 708                 vce_v3_set_bypass_mode(adev, enable);
 709
 710         if (!(adev->cg_flags & AMD_CG_SUPPORT_VCE_MGCG))
 711                 return 0;
 712
 713         mutex_lock(&adev->grbm_idx_mutex);
 714         for (i = 0; i < 2; i++) {
 715                 /* Program VCE Instance 0 or 1 if not harvested */
 716                 if (adev->vce.harvest_config & (1 << i))
 717                         continue;
 718
 719                 WREG32_FIELD(GRBM_GFX_INDEX, VCE_INSTANCE, i);
 720
 721                 if (enable) {
 722                         /* initialize VCE_CLOCK_GATING_A: Clock ON/OFF delay */
 723                         uint32_t data = RREG32(mmVCE_CLOCK_GATING_A);
 724                         data &= ~(0xf | 0xff0);
 725                         data |= ((0x0 << 0) | (0x04 << 4));
 726                         WREG32(mmVCE_CLOCK_GATING_A, data);
 727
 728                         /* initialize VCE_UENC_CLOCK_GATING: Clock ON/OFF delay */
 729                         data = RREG32(mmVCE_UENC_CLOCK_GATING);
 730                         data &= ~(0xf | 0xff0);
 731                         data |= ((0x0 << 0) | (0x04 << 4));
 732                         WREG32(mmVCE_UENC_CLOCK_GATING, data);
 733                 }
 734
 735                 vce_v3_0_set_vce_sw_clock_gating(adev, enable);
 736         }
 737
 738         WREG32_FIELD(GRBM_GFX_INDEX, VCE_INSTANCE, 0);
 739         mutex_unlock(&adev->grbm_idx_mutex);
 740
 741         return 0;
 742 }
 743
 744 static int vce_v3_0_set_powergating_state(void *handle,
 745                                           enum amd_powergating_state state)
 746 {
 747         /* This doesn't actually powergate the VCE block.
 748          * That's done in the dpm code via the SMC.  This
 749          * just re-inits the block as necessary.  The actual
 750          * gating still happens in the dpm code.  We should
 751          * revisit this when there is a cleaner line between
 752          * the smc and the hw blocks
 753          */
 754         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 755
 756         if (!(adev->pg_flags & AMD_PG_SUPPORT_VCE))
 757                 return 0;
 758
 759         if (state == AMD_PG_STATE_GATE)
 760                 /* XXX do we need a vce_v3_0_stop()? */
 761                 return 0;
 762         else
 763                 return vce_v3_0_start(adev);
 764 }
 765
 766 const struct amd_ip_funcs vce_v3_0_ip_funcs = {
 767         .name = "vce_v3_0",
 768         .early_init = vce_v3_0_early_init,
 769         .late_init = NULL,
 770         .sw_init = vce_v3_0_sw_init,
 771         .sw_fini = vce_v3_0_sw_fini,
 772         .hw_init = vce_v3_0_hw_init,
 773         .hw_fini = vce_v3_0_hw_fini,
 774         .suspend = vce_v3_0_suspend,
 775         .resume = vce_v3_0_resume,
 776         .is_idle = vce_v3_0_is_idle,
 777         .wait_for_idle = vce_v3_0_wait_for_idle,
 778         .check_soft_reset = vce_v3_0_check_soft_reset,
 779         .pre_soft_reset = vce_v3_0_pre_soft_reset,
 780         .soft_reset = vce_v3_0_soft_reset,
 781         .post_soft_reset = vce_v3_0_post_soft_reset,
 782         .set_clockgating_state = vce_v3_0_set_clockgating_state,
 783         .set_powergating_state = vce_v3_0_set_powergating_state,
 784 };
 785
 786 static const struct amdgpu_ring_funcs vce_v3_0_ring_funcs = {
 787         .get_rptr = vce_v3_0_ring_get_rptr,
 788         .get_wptr = vce_v3_0_ring_get_wptr,
 789         .set_wptr = vce_v3_0_ring_set_wptr,
 790         .parse_cs = amdgpu_vce_ring_parse_cs,
 791         .emit_ib = amdgpu_vce_ring_emit_ib,
 792         .emit_fence = amdgpu_vce_ring_emit_fence,
 793         .test_ring = amdgpu_vce_ring_test_ring,
 794         .test_ib = amdgpu_vce_ring_test_ib,
 795         .insert_nop = amdgpu_ring_insert_nop,
 796         .pad_ib = amdgpu_ring_generic_pad_ib,
 797         .begin_use = amdgpu_vce_ring_begin_use,
 798         .end_use = amdgpu_vce_ring_end_use,
 799 };
 800
 801 static void vce_v3_0_set_ring_funcs(struct amdgpu_device *adev)
 802 {
 803         adev->vce.ring[0].funcs = &vce_v3_0_ring_funcs;
 804         adev->vce.ring[1].funcs = &vce_v3_0_ring_funcs;
 805 }
 806
 807 static const struct amdgpu_irq_src_funcs vce_v3_0_irq_funcs = {
 808         .set = vce_v3_0_set_interrupt_state,
 809         .process = vce_v3_0_process_interrupt,
 810 };
 811
 812 static void vce_v3_0_set_irq_funcs(struct amdgpu_device *adev)
 813 {
 814         adev->vce.irq.num_types = 1;
 815         adev->vce.irq.funcs = &vce_v3_0_irq_funcs;
 816 };