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 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_sh_mask.h" 41 #include "ivsrcid/ivsrcid_vislands30.h" 42 43 44 #define GRBM_GFX_INDEX__VCE_INSTANCE__SHIFT 0x04 45 #define GRBM_GFX_INDEX__VCE_INSTANCE_MASK 0x10 46 #define GRBM_GFX_INDEX__VCE_ALL_PIPE 0x07 47 48 #define mmVCE_LMI_VCPU_CACHE_40BIT_BAR0 0x8616 49 #define mmVCE_LMI_VCPU_CACHE_40BIT_BAR1 0x8617 50 #define mmVCE_LMI_VCPU_CACHE_40BIT_BAR2 0x8618 51 #define mmGRBM_GFX_INDEX_DEFAULT 0xE0000000 52 53 #define VCE_STATUS_VCPU_REPORT_FW_LOADED_MASK 0x02 54 55 #define VCE_V3_0_FW_SIZE (384 * 1024) 56 #define VCE_V3_0_STACK_SIZE (64 * 1024) 57 #define VCE_V3_0_DATA_SIZE ((16 * 1024 * AMDGPU_MAX_VCE_HANDLES) + (52 * 1024)) 58 59 #define FW_52_8_3 ((52 << 24) | (8 << 16) | (3 << 8)) 60 61 #define GET_VCE_INSTANCE(i) ((i) << GRBM_GFX_INDEX__VCE_INSTANCE__SHIFT \ 62 | GRBM_GFX_INDEX__VCE_ALL_PIPE) 63 64 static void vce_v3_0_mc_resume(struct amdgpu_device *adev, int idx); 65 static void vce_v3_0_set_ring_funcs(struct amdgpu_device *adev); 66 static void vce_v3_0_set_irq_funcs(struct amdgpu_device *adev); 67 static int vce_v3_0_wait_for_idle(struct amdgpu_ip_block *ip_block); 68 static int vce_v3_0_set_clockgating_state(struct amdgpu_ip_block *ip_block, 69 enum amd_clockgating_state state); 70 /** 71 * vce_v3_0_ring_get_rptr - get read pointer 72 * 73 * @ring: amdgpu_ring pointer 74 * 75 * Returns the current hardware read pointer 76 */ 77 static uint64_t vce_v3_0_ring_get_rptr(struct amdgpu_ring *ring) 78 { 79 struct amdgpu_device *adev = ring->adev; 80 u32 v; 81 82 mutex_lock(&adev->grbm_idx_mutex); 83 if (adev->vce.harvest_config == 0 || 84 adev->vce.harvest_config == AMDGPU_VCE_HARVEST_VCE1) 85 WREG32(mmGRBM_GFX_INDEX, GET_VCE_INSTANCE(0)); 86 else if (adev->vce.harvest_config == AMDGPU_VCE_HARVEST_VCE0) 87 WREG32(mmGRBM_GFX_INDEX, GET_VCE_INSTANCE(1)); 88 89 if (ring->me == 0) 90 v = RREG32(mmVCE_RB_RPTR); 91 else if (ring->me == 1) 92 v = RREG32(mmVCE_RB_RPTR2); 93 else 94 v = RREG32(mmVCE_RB_RPTR3); 95 96 WREG32(mmGRBM_GFX_INDEX, mmGRBM_GFX_INDEX_DEFAULT); 97 mutex_unlock(&adev->grbm_idx_mutex); 98 99 return v; 100 } 101 102 /** 103 * vce_v3_0_ring_get_wptr - get write pointer 104 * 105 * @ring: amdgpu_ring pointer 106 * 107 * Returns the current hardware write pointer 108 */ 109 static uint64_t vce_v3_0_ring_get_wptr(struct amdgpu_ring *ring) 110 { 111 struct amdgpu_device *adev = ring->adev; 112 u32 v; 113 114 mutex_lock(&adev->grbm_idx_mutex); 115 if (adev->vce.harvest_config == 0 || 116 adev->vce.harvest_config == AMDGPU_VCE_HARVEST_VCE1) 117 WREG32(mmGRBM_GFX_INDEX, GET_VCE_INSTANCE(0)); 118 else if (adev->vce.harvest_config == AMDGPU_VCE_HARVEST_VCE0) 119 WREG32(mmGRBM_GFX_INDEX, GET_VCE_INSTANCE(1)); 120 121 if (ring->me == 0) 122 v = RREG32(mmVCE_RB_WPTR); 123 else if (ring->me == 1) 124 v = RREG32(mmVCE_RB_WPTR2); 125 else 126 v = RREG32(mmVCE_RB_WPTR3); 127 128 WREG32(mmGRBM_GFX_INDEX, mmGRBM_GFX_INDEX_DEFAULT); 129 mutex_unlock(&adev->grbm_idx_mutex); 130 131 return v; 132 } 133 134 /** 135 * vce_v3_0_ring_set_wptr - set write pointer 136 * 137 * @ring: amdgpu_ring pointer 138 * 139 * Commits the write pointer to the hardware 140 */ 141 static void vce_v3_0_ring_set_wptr(struct amdgpu_ring *ring) 142 { 143 struct amdgpu_device *adev = ring->adev; 144 145 mutex_lock(&adev->grbm_idx_mutex); 146 if (adev->vce.harvest_config == 0 || 147 adev->vce.harvest_config == AMDGPU_VCE_HARVEST_VCE1) 148 WREG32(mmGRBM_GFX_INDEX, GET_VCE_INSTANCE(0)); 149 else if (adev->vce.harvest_config == AMDGPU_VCE_HARVEST_VCE0) 150 WREG32(mmGRBM_GFX_INDEX, GET_VCE_INSTANCE(1)); 151 152 if (ring->me == 0) 153 WREG32(mmVCE_RB_WPTR, lower_32_bits(ring->wptr)); 154 else if (ring->me == 1) 155 WREG32(mmVCE_RB_WPTR2, lower_32_bits(ring->wptr)); 156 else 157 WREG32(mmVCE_RB_WPTR3, lower_32_bits(ring->wptr)); 158 159 WREG32(mmGRBM_GFX_INDEX, mmGRBM_GFX_INDEX_DEFAULT); 160 mutex_unlock(&adev->grbm_idx_mutex); 161 } 162 163 static void vce_v3_0_override_vce_clock_gating(struct amdgpu_device *adev, bool override) 164 { 165 WREG32_FIELD(VCE_RB_ARB_CTRL, VCE_CGTT_OVERRIDE, override ? 1 : 0); 166 } 167 168 static void vce_v3_0_set_vce_sw_clock_gating(struct amdgpu_device *adev, 169 bool gated) 170 { 171 u32 data; 172 173 /* Set Override to disable Clock Gating */ 174 vce_v3_0_override_vce_clock_gating(adev, true); 175 176 /* This function enables MGCG which is controlled by firmware. 177 With the clocks in the gated state the core is still 178 accessible but the firmware will throttle the clocks on the 179 fly as necessary. 180 */ 181 if (!gated) { 182 data = RREG32(mmVCE_CLOCK_GATING_B); 183 data |= 0x1ff; 184 data &= ~0xef0000; 185 WREG32(mmVCE_CLOCK_GATING_B, data); 186 187 data = RREG32(mmVCE_UENC_CLOCK_GATING); 188 data |= 0x3ff000; 189 data &= ~0xffc00000; 190 WREG32(mmVCE_UENC_CLOCK_GATING, data); 191 192 data = RREG32(mmVCE_UENC_CLOCK_GATING_2); 193 data |= 0x2; 194 data &= ~0x00010000; 195 WREG32(mmVCE_UENC_CLOCK_GATING_2, data); 196 197 data = RREG32(mmVCE_UENC_REG_CLOCK_GATING); 198 data |= 0x37f; 199 WREG32(mmVCE_UENC_REG_CLOCK_GATING, data); 200 201 data = RREG32(mmVCE_UENC_DMA_DCLK_CTRL); 202 data |= VCE_UENC_DMA_DCLK_CTRL__WRDMCLK_FORCEON_MASK | 203 VCE_UENC_DMA_DCLK_CTRL__RDDMCLK_FORCEON_MASK | 204 VCE_UENC_DMA_DCLK_CTRL__REGCLK_FORCEON_MASK | 205 0x8; 206 WREG32(mmVCE_UENC_DMA_DCLK_CTRL, data); 207 } else { 208 data = RREG32(mmVCE_CLOCK_GATING_B); 209 data &= ~0x80010; 210 data |= 0xe70008; 211 WREG32(mmVCE_CLOCK_GATING_B, data); 212 213 data = RREG32(mmVCE_UENC_CLOCK_GATING); 214 data |= 0xffc00000; 215 WREG32(mmVCE_UENC_CLOCK_GATING, data); 216 217 data = RREG32(mmVCE_UENC_CLOCK_GATING_2); 218 data |= 0x10000; 219 WREG32(mmVCE_UENC_CLOCK_GATING_2, data); 220 221 data = RREG32(mmVCE_UENC_REG_CLOCK_GATING); 222 data &= ~0x3ff; 223 WREG32(mmVCE_UENC_REG_CLOCK_GATING, data); 224 225 data = RREG32(mmVCE_UENC_DMA_DCLK_CTRL); 226 data &= ~(VCE_UENC_DMA_DCLK_CTRL__WRDMCLK_FORCEON_MASK | 227 VCE_UENC_DMA_DCLK_CTRL__RDDMCLK_FORCEON_MASK | 228 VCE_UENC_DMA_DCLK_CTRL__REGCLK_FORCEON_MASK | 229 0x8); 230 WREG32(mmVCE_UENC_DMA_DCLK_CTRL, data); 231 } 232 vce_v3_0_override_vce_clock_gating(adev, false); 233 } 234 235 static int vce_v3_0_firmware_loaded(struct amdgpu_device *adev) 236 { 237 int i, j; 238 239 for (i = 0; i < 10; ++i) { 240 for (j = 0; j < 100; ++j) { 241 uint32_t status = RREG32(mmVCE_STATUS); 242 243 if (status & VCE_STATUS_VCPU_REPORT_FW_LOADED_MASK) 244 return 0; 245 mdelay(10); 246 } 247 248 DRM_ERROR("VCE not responding, trying to reset the ECPU!!!\n"); 249 WREG32_FIELD(VCE_SOFT_RESET, ECPU_SOFT_RESET, 1); 250 mdelay(10); 251 WREG32_FIELD(VCE_SOFT_RESET, ECPU_SOFT_RESET, 0); 252 mdelay(10); 253 } 254 255 return -ETIMEDOUT; 256 } 257 258 /** 259 * vce_v3_0_start - start VCE block 260 * 261 * @adev: amdgpu_device pointer 262 * 263 * Setup and start the VCE block 264 */ 265 static int vce_v3_0_start(struct amdgpu_device *adev) 266 { 267 struct amdgpu_ring *ring; 268 int idx, r; 269 270 mutex_lock(&adev->grbm_idx_mutex); 271 for (idx = 0; idx < 2; ++idx) { 272 if (adev->vce.harvest_config & (1 << idx)) 273 continue; 274 275 WREG32(mmGRBM_GFX_INDEX, GET_VCE_INSTANCE(idx)); 276 277 /* Program instance 0 reg space for two instances or instance 0 case 278 program instance 1 reg space for only instance 1 available case */ 279 if (idx != 1 || adev->vce.harvest_config == AMDGPU_VCE_HARVEST_VCE0) { 280 ring = &adev->vce.ring[0]; 281 WREG32(mmVCE_RB_RPTR, lower_32_bits(ring->wptr)); 282 WREG32(mmVCE_RB_WPTR, lower_32_bits(ring->wptr)); 283 WREG32(mmVCE_RB_BASE_LO, ring->gpu_addr); 284 WREG32(mmVCE_RB_BASE_HI, upper_32_bits(ring->gpu_addr)); 285 WREG32(mmVCE_RB_SIZE, ring->ring_size / 4); 286 287 ring = &adev->vce.ring[1]; 288 WREG32(mmVCE_RB_RPTR2, lower_32_bits(ring->wptr)); 289 WREG32(mmVCE_RB_WPTR2, lower_32_bits(ring->wptr)); 290 WREG32(mmVCE_RB_BASE_LO2, ring->gpu_addr); 291 WREG32(mmVCE_RB_BASE_HI2, upper_32_bits(ring->gpu_addr)); 292 WREG32(mmVCE_RB_SIZE2, ring->ring_size / 4); 293 294 ring = &adev->vce.ring[2]; 295 WREG32(mmVCE_RB_RPTR3, lower_32_bits(ring->wptr)); 296 WREG32(mmVCE_RB_WPTR3, lower_32_bits(ring->wptr)); 297 WREG32(mmVCE_RB_BASE_LO3, ring->gpu_addr); 298 WREG32(mmVCE_RB_BASE_HI3, upper_32_bits(ring->gpu_addr)); 299 WREG32(mmVCE_RB_SIZE3, ring->ring_size / 4); 300 } 301 302 vce_v3_0_mc_resume(adev, idx); 303 WREG32_FIELD(VCE_STATUS, JOB_BUSY, 1); 304 305 if (adev->asic_type >= CHIP_STONEY) 306 WREG32_P(mmVCE_VCPU_CNTL, 1, ~0x200001); 307 else 308 WREG32_FIELD(VCE_VCPU_CNTL, CLK_EN, 1); 309 310 WREG32_FIELD(VCE_SOFT_RESET, ECPU_SOFT_RESET, 0); 311 mdelay(100); 312 313 r = vce_v3_0_firmware_loaded(adev); 314 315 /* clear BUSY flag */ 316 WREG32_FIELD(VCE_STATUS, JOB_BUSY, 0); 317 318 if (r) { 319 DRM_ERROR("VCE not responding, giving up!!!\n"); 320 mutex_unlock(&adev->grbm_idx_mutex); 321 return r; 322 } 323 } 324 325 WREG32(mmGRBM_GFX_INDEX, mmGRBM_GFX_INDEX_DEFAULT); 326 mutex_unlock(&adev->grbm_idx_mutex); 327 328 return 0; 329 } 330 331 static int vce_v3_0_stop(struct amdgpu_device *adev) 332 { 333 int idx; 334 335 mutex_lock(&adev->grbm_idx_mutex); 336 for (idx = 0; idx < 2; ++idx) { 337 if (adev->vce.harvest_config & (1 << idx)) 338 continue; 339 340 WREG32(mmGRBM_GFX_INDEX, GET_VCE_INSTANCE(idx)); 341 342 if (adev->asic_type >= CHIP_STONEY) 343 WREG32_P(mmVCE_VCPU_CNTL, 0, ~0x200001); 344 else 345 WREG32_FIELD(VCE_VCPU_CNTL, CLK_EN, 0); 346 347 /* hold on ECPU */ 348 WREG32_FIELD(VCE_SOFT_RESET, ECPU_SOFT_RESET, 1); 349 350 /* clear VCE STATUS */ 351 WREG32(mmVCE_STATUS, 0); 352 } 353 354 WREG32(mmGRBM_GFX_INDEX, mmGRBM_GFX_INDEX_DEFAULT); 355 mutex_unlock(&adev->grbm_idx_mutex); 356 357 return 0; 358 } 359 360 #define ixVCE_HARVEST_FUSE_MACRO__ADDRESS 0xC0014074 361 #define VCE_HARVEST_FUSE_MACRO__SHIFT 27 362 #define VCE_HARVEST_FUSE_MACRO__MASK 0x18000000 363 364 static unsigned vce_v3_0_get_harvest_config(struct amdgpu_device *adev) 365 { 366 u32 tmp; 367 368 if ((adev->asic_type == CHIP_FIJI) || 369 (adev->asic_type == CHIP_STONEY)) 370 return AMDGPU_VCE_HARVEST_VCE1; 371 372 if (adev->flags & AMD_IS_APU) 373 tmp = (RREG32_SMC(ixVCE_HARVEST_FUSE_MACRO__ADDRESS) & 374 VCE_HARVEST_FUSE_MACRO__MASK) >> 375 VCE_HARVEST_FUSE_MACRO__SHIFT; 376 else 377 tmp = (RREG32_SMC(ixCC_HARVEST_FUSES) & 378 CC_HARVEST_FUSES__VCE_DISABLE_MASK) >> 379 CC_HARVEST_FUSES__VCE_DISABLE__SHIFT; 380 381 switch (tmp) { 382 case 1: 383 return AMDGPU_VCE_HARVEST_VCE0; 384 case 2: 385 return AMDGPU_VCE_HARVEST_VCE1; 386 case 3: 387 return AMDGPU_VCE_HARVEST_VCE0 | AMDGPU_VCE_HARVEST_VCE1; 388 default: 389 if ((adev->asic_type == CHIP_POLARIS10) || 390 (adev->asic_type == CHIP_POLARIS11) || 391 (adev->asic_type == CHIP_POLARIS12) || 392 (adev->asic_type == CHIP_VEGAM)) 393 return AMDGPU_VCE_HARVEST_VCE1; 394 395 return 0; 396 } 397 } 398 399 static int vce_v3_0_early_init(struct amdgpu_ip_block *ip_block) 400 { 401 struct amdgpu_device *adev = ip_block->adev; 402 int r; 403 404 adev->vce.harvest_config = vce_v3_0_get_harvest_config(adev); 405 406 if ((adev->vce.harvest_config & 407 (AMDGPU_VCE_HARVEST_VCE0 | AMDGPU_VCE_HARVEST_VCE1)) == 408 (AMDGPU_VCE_HARVEST_VCE0 | AMDGPU_VCE_HARVEST_VCE1)) 409 return -ENOENT; 410 411 r = amdgpu_vce_early_init(adev); 412 if (r) 413 return r; 414 415 adev->vce.num_rings = 3; 416 417 vce_v3_0_set_ring_funcs(adev); 418 vce_v3_0_set_irq_funcs(adev); 419 420 return 0; 421 } 422 423 static int vce_v3_0_sw_init(struct amdgpu_ip_block *ip_block) 424 { 425 struct amdgpu_device *adev = ip_block->adev; 426 struct amdgpu_ring *ring; 427 int r, i; 428 429 /* VCE */ 430 r = amdgpu_irq_add_id(adev, AMDGPU_IRQ_CLIENTID_LEGACY, VISLANDS30_IV_SRCID_VCE_TRAP, &adev->vce.irq); 431 if (r) 432 return r; 433 434 r = amdgpu_vce_sw_init(adev, VCE_V3_0_FW_SIZE + 435 (VCE_V3_0_STACK_SIZE + VCE_V3_0_DATA_SIZE) * 2); 436 if (r) 437 return r; 438 439 /* 52.8.3 required for 3 ring support */ 440 if (adev->vce.fw_version < FW_52_8_3) 441 adev->vce.num_rings = 2; 442 443 r = amdgpu_vce_resume(adev); 444 if (r) 445 return r; 446 447 for (i = 0; i < adev->vce.num_rings; i++) { 448 enum amdgpu_ring_priority_level hw_prio = amdgpu_vce_get_ring_prio(i); 449 450 ring = &adev->vce.ring[i]; 451 sprintf(ring->name, "vce%d", i); 452 r = amdgpu_ring_init(adev, ring, 512, &adev->vce.irq, 0, 453 hw_prio, NULL); 454 if (r) 455 return r; 456 } 457 458 return r; 459 } 460 461 static int vce_v3_0_sw_fini(struct amdgpu_ip_block *ip_block) 462 { 463 int r; 464 struct amdgpu_device *adev = ip_block->adev; 465 466 r = amdgpu_vce_suspend(adev); 467 if (r) 468 return r; 469 470 return amdgpu_vce_sw_fini(adev); 471 } 472 473 static int vce_v3_0_hw_init(struct amdgpu_ip_block *ip_block) 474 { 475 int r, i; 476 struct amdgpu_device *adev = ip_block->adev; 477 478 vce_v3_0_override_vce_clock_gating(adev, true); 479 480 amdgpu_asic_set_vce_clocks(adev, 10000, 10000); 481 482 for (i = 0; i < adev->vce.num_rings; i++) { 483 r = amdgpu_ring_test_helper(&adev->vce.ring[i]); 484 if (r) 485 return r; 486 } 487 488 drm_info(adev_to_drm(adev), "VCE initialized successfully.\n"); 489 490 return 0; 491 } 492 493 static int vce_v3_0_hw_fini(struct amdgpu_ip_block *ip_block) 494 { 495 int r; 496 struct amdgpu_device *adev = ip_block->adev; 497 498 cancel_delayed_work_sync(&adev->vce.idle_work); 499 500 r = vce_v3_0_wait_for_idle(ip_block); 501 if (r) 502 return r; 503 504 vce_v3_0_stop(adev); 505 return vce_v3_0_set_clockgating_state(ip_block, AMD_CG_STATE_GATE); 506 } 507 508 static int vce_v3_0_suspend(struct amdgpu_ip_block *ip_block) 509 { 510 int r; 511 struct amdgpu_device *adev = ip_block->adev; 512 513 /* 514 * Proper cleanups before halting the HW engine: 515 * - cancel the delayed idle work 516 * - enable powergating 517 * - enable clockgating 518 * - disable dpm 519 * 520 * TODO: to align with the VCN implementation, move the 521 * jobs for clockgating/powergating/dpm setting to 522 * ->set_powergating_state(). 523 */ 524 cancel_delayed_work_sync(&adev->vce.idle_work); 525 526 if (adev->pm.dpm_enabled) { 527 amdgpu_dpm_enable_vce(adev, false); 528 } else { 529 amdgpu_asic_set_vce_clocks(adev, 0, 0); 530 amdgpu_device_ip_set_powergating_state(adev, AMD_IP_BLOCK_TYPE_VCE, 531 AMD_PG_STATE_GATE); 532 amdgpu_device_ip_set_clockgating_state(adev, AMD_IP_BLOCK_TYPE_VCE, 533 AMD_CG_STATE_GATE); 534 } 535 536 r = vce_v3_0_hw_fini(ip_block); 537 if (r) 538 return r; 539 540 return amdgpu_vce_suspend(adev); 541 } 542 543 static int vce_v3_0_resume(struct amdgpu_ip_block *ip_block) 544 { 545 int r; 546 547 r = amdgpu_vce_resume(ip_block->adev); 548 if (r) 549 return r; 550 551 return vce_v3_0_hw_init(ip_block); 552 } 553 554 static void vce_v3_0_mc_resume(struct amdgpu_device *adev, int idx) 555 { 556 uint32_t offset, size; 557 558 WREG32_P(mmVCE_CLOCK_GATING_A, 0, ~(1 << 16)); 559 WREG32_P(mmVCE_UENC_CLOCK_GATING, 0x1FF000, ~0xFF9FF000); 560 WREG32_P(mmVCE_UENC_REG_CLOCK_GATING, 0x3F, ~0x3F); 561 WREG32(mmVCE_CLOCK_GATING_B, 0x1FF); 562 563 WREG32(mmVCE_LMI_CTRL, 0x00398000); 564 WREG32_P(mmVCE_LMI_CACHE_CTRL, 0x0, ~0x1); 565 WREG32(mmVCE_LMI_SWAP_CNTL, 0); 566 WREG32(mmVCE_LMI_SWAP_CNTL1, 0); 567 WREG32(mmVCE_LMI_VM_CTRL, 0); 568 WREG32_OR(mmVCE_VCPU_CNTL, 0x00100000); 569 570 if (adev->asic_type >= CHIP_STONEY) { 571 WREG32(mmVCE_LMI_VCPU_CACHE_40BIT_BAR0, (adev->vce.gpu_addr >> 8)); 572 WREG32(mmVCE_LMI_VCPU_CACHE_40BIT_BAR1, (adev->vce.gpu_addr >> 8)); 573 WREG32(mmVCE_LMI_VCPU_CACHE_40BIT_BAR2, (adev->vce.gpu_addr >> 8)); 574 } else 575 WREG32(mmVCE_LMI_VCPU_CACHE_40BIT_BAR, (adev->vce.gpu_addr >> 8)); 576 offset = AMDGPU_VCE_FIRMWARE_OFFSET; 577 size = VCE_V3_0_FW_SIZE - AMDGPU_VCE_FIRMWARE_OFFSET; 578 WREG32(mmVCE_VCPU_CACHE_OFFSET0, offset & 0x7fffffff); 579 WREG32(mmVCE_VCPU_CACHE_SIZE0, size); 580 581 if (idx == 0) { 582 offset += size; 583 size = VCE_V3_0_STACK_SIZE; 584 WREG32(mmVCE_VCPU_CACHE_OFFSET1, offset & 0x7fffffff); 585 WREG32(mmVCE_VCPU_CACHE_SIZE1, size); 586 offset += size; 587 size = VCE_V3_0_DATA_SIZE; 588 WREG32(mmVCE_VCPU_CACHE_OFFSET2, offset & 0x7fffffff); 589 WREG32(mmVCE_VCPU_CACHE_SIZE2, size); 590 } else { 591 offset += size + VCE_V3_0_STACK_SIZE + VCE_V3_0_DATA_SIZE; 592 size = VCE_V3_0_STACK_SIZE; 593 WREG32(mmVCE_VCPU_CACHE_OFFSET1, offset & 0xfffffff); 594 WREG32(mmVCE_VCPU_CACHE_SIZE1, size); 595 offset += size; 596 size = VCE_V3_0_DATA_SIZE; 597 WREG32(mmVCE_VCPU_CACHE_OFFSET2, offset & 0xfffffff); 598 WREG32(mmVCE_VCPU_CACHE_SIZE2, size); 599 } 600 601 WREG32_P(mmVCE_LMI_CTRL2, 0x0, ~0x100); 602 WREG32_FIELD(VCE_SYS_INT_EN, VCE_SYS_INT_TRAP_INTERRUPT_EN, 1); 603 } 604 605 static bool vce_v3_0_is_idle(struct amdgpu_ip_block *ip_block) 606 { 607 struct amdgpu_device *adev = ip_block->adev; 608 u32 mask = 0; 609 610 mask |= (adev->vce.harvest_config & AMDGPU_VCE_HARVEST_VCE0) ? 0 : SRBM_STATUS2__VCE0_BUSY_MASK; 611 mask |= (adev->vce.harvest_config & AMDGPU_VCE_HARVEST_VCE1) ? 0 : SRBM_STATUS2__VCE1_BUSY_MASK; 612 613 return !(RREG32(mmSRBM_STATUS2) & mask); 614 } 615 616 static int vce_v3_0_wait_for_idle(struct amdgpu_ip_block *ip_block) 617 { 618 unsigned i; 619 struct amdgpu_device *adev = ip_block->adev; 620 621 for (i = 0; i < adev->usec_timeout; i++) 622 if (vce_v3_0_is_idle(ip_block)) 623 return 0; 624 625 return -ETIMEDOUT; 626 } 627 628 #define VCE_STATUS_VCPU_REPORT_AUTO_BUSY_MASK 0x00000008L /* AUTO_BUSY */ 629 #define VCE_STATUS_VCPU_REPORT_RB0_BUSY_MASK 0x00000010L /* RB0_BUSY */ 630 #define VCE_STATUS_VCPU_REPORT_RB1_BUSY_MASK 0x00000020L /* RB1_BUSY */ 631 #define AMDGPU_VCE_STATUS_BUSY_MASK (VCE_STATUS_VCPU_REPORT_AUTO_BUSY_MASK | \ 632 VCE_STATUS_VCPU_REPORT_RB0_BUSY_MASK) 633 634 static int vce_v3_0_soft_reset(struct amdgpu_ip_block *ip_block) 635 { 636 struct amdgpu_device *adev = ip_block->adev; 637 u32 srbm_soft_reset; 638 639 if (!adev->vce.srbm_soft_reset) 640 return 0; 641 srbm_soft_reset = adev->vce.srbm_soft_reset; 642 643 if (srbm_soft_reset) { 644 u32 tmp; 645 646 tmp = RREG32(mmSRBM_SOFT_RESET); 647 tmp |= srbm_soft_reset; 648 dev_info(adev->dev, "SRBM_SOFT_RESET=0x%08X\n", tmp); 649 WREG32(mmSRBM_SOFT_RESET, tmp); 650 tmp = RREG32(mmSRBM_SOFT_RESET); 651 652 udelay(50); 653 654 tmp &= ~srbm_soft_reset; 655 WREG32(mmSRBM_SOFT_RESET, tmp); 656 tmp = RREG32(mmSRBM_SOFT_RESET); 657 658 /* Wait a little for things to settle down */ 659 udelay(50); 660 } 661 662 return 0; 663 } 664 665 static int vce_v3_0_set_interrupt_state(struct amdgpu_device *adev, 666 struct amdgpu_irq_src *source, 667 unsigned type, 668 enum amdgpu_interrupt_state state) 669 { 670 uint32_t val = 0; 671 672 if (state == AMDGPU_IRQ_STATE_ENABLE) 673 val |= VCE_SYS_INT_EN__VCE_SYS_INT_TRAP_INTERRUPT_EN_MASK; 674 675 WREG32_P(mmVCE_SYS_INT_EN, val, ~VCE_SYS_INT_EN__VCE_SYS_INT_TRAP_INTERRUPT_EN_MASK); 676 return 0; 677 } 678 679 static int vce_v3_0_process_interrupt(struct amdgpu_device *adev, 680 struct amdgpu_irq_src *source, 681 struct amdgpu_iv_entry *entry) 682 { 683 DRM_DEBUG("IH: VCE\n"); 684 685 WREG32_FIELD(VCE_SYS_INT_STATUS, VCE_SYS_INT_TRAP_INTERRUPT_INT, 1); 686 687 switch (entry->src_data[0]) { 688 case 0: 689 case 1: 690 case 2: 691 amdgpu_fence_process(&adev->vce.ring[entry->src_data[0]]); 692 break; 693 default: 694 DRM_ERROR("Unhandled interrupt: %d %d\n", 695 entry->src_id, entry->src_data[0]); 696 break; 697 } 698 699 return 0; 700 } 701 702 static int vce_v3_0_set_clockgating_state(struct amdgpu_ip_block *ip_block, 703 enum amd_clockgating_state state) 704 { 705 struct amdgpu_device *adev = ip_block->adev; 706 bool enable = (state == AMD_CG_STATE_GATE); 707 int i; 708 709 if (!(adev->cg_flags & AMD_CG_SUPPORT_VCE_MGCG)) 710 return 0; 711 712 mutex_lock(&adev->grbm_idx_mutex); 713 for (i = 0; i < 2; i++) { 714 /* Program VCE Instance 0 or 1 if not harvested */ 715 if (adev->vce.harvest_config & (1 << i)) 716 continue; 717 718 WREG32(mmGRBM_GFX_INDEX, GET_VCE_INSTANCE(i)); 719 720 if (!enable) { 721 /* initialize VCE_CLOCK_GATING_A: Clock ON/OFF delay */ 722 uint32_t data = RREG32(mmVCE_CLOCK_GATING_A); 723 data &= ~(0xf | 0xff0); 724 data |= ((0x0 << 0) | (0x04 << 4)); 725 WREG32(mmVCE_CLOCK_GATING_A, data); 726 727 /* initialize VCE_UENC_CLOCK_GATING: Clock ON/OFF delay */ 728 data = RREG32(mmVCE_UENC_CLOCK_GATING); 729 data &= ~(0xf | 0xff0); 730 data |= ((0x0 << 0) | (0x04 << 4)); 731 WREG32(mmVCE_UENC_CLOCK_GATING, data); 732 } 733 734 vce_v3_0_set_vce_sw_clock_gating(adev, enable); 735 } 736 737 WREG32(mmGRBM_GFX_INDEX, mmGRBM_GFX_INDEX_DEFAULT); 738 mutex_unlock(&adev->grbm_idx_mutex); 739 740 return 0; 741 } 742 743 static int vce_v3_0_set_powergating_state(struct amdgpu_ip_block *ip_block, 744 enum amd_powergating_state state) 745 { 746 /* This doesn't actually powergate the VCE block. 747 * That's done in the dpm code via the SMC. This 748 * just re-inits the block as necessary. The actual 749 * gating still happens in the dpm code. We should 750 * revisit this when there is a cleaner line between 751 * the smc and the hw blocks 752 */ 753 struct amdgpu_device *adev = ip_block->adev; 754 int ret = 0; 755 756 if (state == AMD_PG_STATE_GATE) { 757 ret = vce_v3_0_stop(adev); 758 if (ret) 759 goto out; 760 } else { 761 ret = vce_v3_0_start(adev); 762 if (ret) 763 goto out; 764 } 765 766 out: 767 return ret; 768 } 769 770 static void vce_v3_0_get_clockgating_state(struct amdgpu_ip_block *ip_block, u64 *flags) 771 { 772 struct amdgpu_device *adev = ip_block->adev; 773 int data; 774 775 mutex_lock(&adev->pm.mutex); 776 777 if (adev->flags & AMD_IS_APU) 778 data = RREG32_SMC(ixCURRENT_PG_STATUS_APU); 779 else 780 data = RREG32_SMC(ixCURRENT_PG_STATUS); 781 782 if (data & CURRENT_PG_STATUS__VCE_PG_STATUS_MASK) { 783 drm_info(adev_to_drm(adev), "Cannot get clockgating state when VCE is powergated.\n"); 784 goto out; 785 } 786 787 WREG32_FIELD(GRBM_GFX_INDEX, VCE_INSTANCE, 0); 788 789 /* AMD_CG_SUPPORT_VCE_MGCG */ 790 data = RREG32(mmVCE_CLOCK_GATING_A); 791 if (data & (0x04 << 4)) 792 *flags |= AMD_CG_SUPPORT_VCE_MGCG; 793 794 out: 795 mutex_unlock(&adev->pm.mutex); 796 } 797 798 static void vce_v3_0_ring_emit_ib(struct amdgpu_ring *ring, 799 struct amdgpu_job *job, 800 struct amdgpu_ib *ib, 801 uint32_t flags) 802 { 803 unsigned vmid = AMDGPU_JOB_GET_VMID(job); 804 805 amdgpu_ring_write(ring, VCE_CMD_IB_VM); 806 amdgpu_ring_write(ring, vmid); 807 amdgpu_ring_write(ring, lower_32_bits(ib->gpu_addr)); 808 amdgpu_ring_write(ring, upper_32_bits(ib->gpu_addr)); 809 amdgpu_ring_write(ring, ib->length_dw); 810 } 811 812 static void vce_v3_0_ring_emit_fence(struct amdgpu_ring *ring, u64 addr, 813 u64 seq, unsigned flags) 814 { 815 WARN_ON(flags & AMDGPU_FENCE_FLAG_64BIT); 816 817 amdgpu_ring_write(ring, VCE_CMD_FENCE); 818 amdgpu_ring_write(ring, addr); 819 amdgpu_ring_write(ring, upper_32_bits(addr)); 820 amdgpu_ring_write(ring, seq); 821 amdgpu_ring_write(ring, VCE_CMD_TRAP); 822 } 823 824 static void vce_v3_0_ring_insert_end(struct amdgpu_ring *ring) 825 { 826 amdgpu_ring_write(ring, VCE_CMD_END); 827 } 828 829 static void vce_v3_0_emit_vm_flush(struct amdgpu_ring *ring, 830 unsigned int vmid, uint64_t pd_addr) 831 { 832 amdgpu_ring_write(ring, VCE_CMD_UPDATE_PTB); 833 amdgpu_ring_write(ring, vmid); 834 amdgpu_ring_write(ring, pd_addr >> 12); 835 836 amdgpu_ring_write(ring, VCE_CMD_FLUSH_TLB); 837 amdgpu_ring_write(ring, vmid); 838 } 839 840 static void vce_v3_0_emit_pipeline_sync(struct amdgpu_ring *ring) 841 { 842 uint32_t seq = ring->fence_drv.sync_seq; 843 uint64_t addr = ring->fence_drv.gpu_addr; 844 845 amdgpu_ring_write(ring, VCE_CMD_WAIT_GE); 846 amdgpu_ring_write(ring, lower_32_bits(addr)); 847 amdgpu_ring_write(ring, upper_32_bits(addr)); 848 amdgpu_ring_write(ring, seq); 849 } 850 851 static const struct amd_ip_funcs vce_v3_0_ip_funcs = { 852 .name = "vce_v3_0", 853 .early_init = vce_v3_0_early_init, 854 .sw_init = vce_v3_0_sw_init, 855 .sw_fini = vce_v3_0_sw_fini, 856 .hw_init = vce_v3_0_hw_init, 857 .hw_fini = vce_v3_0_hw_fini, 858 .suspend = vce_v3_0_suspend, 859 .resume = vce_v3_0_resume, 860 .is_idle = vce_v3_0_is_idle, 861 .wait_for_idle = vce_v3_0_wait_for_idle, 862 .soft_reset = vce_v3_0_soft_reset, 863 .set_clockgating_state = vce_v3_0_set_clockgating_state, 864 .set_powergating_state = vce_v3_0_set_powergating_state, 865 .get_clockgating_state = vce_v3_0_get_clockgating_state, 866 }; 867 868 static const struct amdgpu_ring_funcs vce_v3_0_ring_phys_funcs = { 869 .type = AMDGPU_RING_TYPE_VCE, 870 .align_mask = 0xf, 871 .nop = VCE_CMD_NO_OP, 872 .support_64bit_ptrs = false, 873 .no_user_fence = true, 874 .get_rptr = vce_v3_0_ring_get_rptr, 875 .get_wptr = vce_v3_0_ring_get_wptr, 876 .set_wptr = vce_v3_0_ring_set_wptr, 877 .parse_cs = amdgpu_vce_ring_parse_cs, 878 .emit_frame_size = 879 4 + /* vce_v3_0_emit_pipeline_sync */ 880 6, /* amdgpu_vce_ring_emit_fence x1 no user fence */ 881 .emit_ib_size = 4, /* amdgpu_vce_ring_emit_ib */ 882 .emit_ib = amdgpu_vce_ring_emit_ib, 883 .emit_fence = amdgpu_vce_ring_emit_fence, 884 .test_ring = amdgpu_vce_ring_test_ring, 885 .test_ib = amdgpu_vce_ring_test_ib, 886 .insert_nop = amdgpu_ring_insert_nop, 887 .pad_ib = amdgpu_ring_generic_pad_ib, 888 .begin_use = amdgpu_vce_ring_begin_use, 889 .end_use = amdgpu_vce_ring_end_use, 890 }; 891 892 static const struct amdgpu_ring_funcs vce_v3_0_ring_vm_funcs = { 893 .type = AMDGPU_RING_TYPE_VCE, 894 .align_mask = 0xf, 895 .nop = VCE_CMD_NO_OP, 896 .support_64bit_ptrs = false, 897 .no_user_fence = true, 898 .get_rptr = vce_v3_0_ring_get_rptr, 899 .get_wptr = vce_v3_0_ring_get_wptr, 900 .set_wptr = vce_v3_0_ring_set_wptr, 901 .patch_cs_in_place = amdgpu_vce_ring_parse_cs_vm, 902 .emit_frame_size = 903 5 + /* vce_v3_0_emit_vm_flush */ 904 4 + /* vce_v3_0_emit_pipeline_sync */ 905 5 + 5 + /* vce_v3_0_ring_emit_fence x2 vm fence */ 906 1, /* vce_v3_0_ring_insert_end */ 907 .emit_ib_size = 5, /* vce_v3_0_ring_emit_ib */ 908 .emit_ib = vce_v3_0_ring_emit_ib, 909 .emit_vm_flush = vce_v3_0_emit_vm_flush, 910 .emit_pipeline_sync = vce_v3_0_emit_pipeline_sync, 911 .emit_fence = vce_v3_0_ring_emit_fence, 912 .test_ring = amdgpu_vce_ring_test_ring, 913 .test_ib = amdgpu_vce_ring_test_ib, 914 .insert_nop = amdgpu_ring_insert_nop, 915 .insert_end = vce_v3_0_ring_insert_end, 916 .pad_ib = amdgpu_ring_generic_pad_ib, 917 .begin_use = amdgpu_vce_ring_begin_use, 918 .end_use = amdgpu_vce_ring_end_use, 919 }; 920 921 static void vce_v3_0_set_ring_funcs(struct amdgpu_device *adev) 922 { 923 int i; 924 925 if (adev->asic_type >= CHIP_STONEY) { 926 for (i = 0; i < adev->vce.num_rings; i++) { 927 adev->vce.ring[i].funcs = &vce_v3_0_ring_vm_funcs; 928 adev->vce.ring[i].me = i; 929 } 930 drm_info(adev_to_drm(adev), "VCE enabled in VM mode\n"); 931 } else { 932 for (i = 0; i < adev->vce.num_rings; i++) { 933 adev->vce.ring[i].funcs = &vce_v3_0_ring_phys_funcs; 934 adev->vce.ring[i].me = i; 935 } 936 drm_info(adev_to_drm(adev), "VCE enabled in physical mode\n"); 937 } 938 } 939 940 static const struct amdgpu_irq_src_funcs vce_v3_0_irq_funcs = { 941 .set = vce_v3_0_set_interrupt_state, 942 .process = vce_v3_0_process_interrupt, 943 }; 944 945 static void vce_v3_0_set_irq_funcs(struct amdgpu_device *adev) 946 { 947 adev->vce.irq.num_types = 1; 948 adev->vce.irq.funcs = &vce_v3_0_irq_funcs; 949 }; 950 951 const struct amdgpu_ip_block_version vce_v3_0_ip_block = { 952 .type = AMD_IP_BLOCK_TYPE_VCE, 953 .major = 3, 954 .minor = 0, 955 .rev = 0, 956 .funcs = &vce_v3_0_ip_funcs, 957 }; 958 959 const struct amdgpu_ip_block_version vce_v3_1_ip_block = { 960 .type = AMD_IP_BLOCK_TYPE_VCE, 961 .major = 3, 962 .minor = 1, 963 .rev = 0, 964 .funcs = &vce_v3_0_ip_funcs, 965 }; 966 967 const struct amdgpu_ip_block_version vce_v3_4_ip_block = { 968 .type = AMD_IP_BLOCK_TYPE_VCE, 969 .major = 3, 970 .minor = 4, 971 .rev = 0, 972 .funcs = &vce_v3_0_ip_funcs, 973 }; 974