1 /* 2 * Copyright 2014 Advanced Micro Devices, Inc. 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 */ 23 24 #include <linux/firmware.h> 25 #include <linux/module.h> 26 #include <linux/pci.h> 27 28 #include <drm/drm_cache.h> 29 #include "amdgpu.h" 30 #include "gmc_v6_0.h" 31 #include "amdgpu_ucode.h" 32 #include "amdgpu_gem.h" 33 34 #include "bif/bif_3_0_d.h" 35 #include "bif/bif_3_0_sh_mask.h" 36 #include "oss/oss_1_0_d.h" 37 #include "oss/oss_1_0_sh_mask.h" 38 #include "gmc/gmc_6_0_d.h" 39 #include "gmc/gmc_6_0_sh_mask.h" 40 #include "dce/dce_6_0_d.h" 41 #include "dce/dce_6_0_sh_mask.h" 42 #include "si_enums.h" 43 44 static void gmc_v6_0_set_gmc_funcs(struct amdgpu_device *adev); 45 static void gmc_v6_0_set_irq_funcs(struct amdgpu_device *adev); 46 static int gmc_v6_0_wait_for_idle(struct amdgpu_ip_block *ip_block); 47 48 MODULE_FIRMWARE("amdgpu/tahiti_mc.bin"); 49 MODULE_FIRMWARE("amdgpu/pitcairn_mc.bin"); 50 MODULE_FIRMWARE("amdgpu/verde_mc.bin"); 51 MODULE_FIRMWARE("amdgpu/oland_mc.bin"); 52 MODULE_FIRMWARE("amdgpu/hainan_mc.bin"); 53 MODULE_FIRMWARE("amdgpu/si58_mc.bin"); 54 55 #define MC_SEQ_MISC0__MT__MASK 0xf0000000 56 #define MC_SEQ_MISC0__MT__GDDR1 0x10000000 57 #define MC_SEQ_MISC0__MT__DDR2 0x20000000 58 #define MC_SEQ_MISC0__MT__GDDR3 0x30000000 59 #define MC_SEQ_MISC0__MT__GDDR4 0x40000000 60 #define MC_SEQ_MISC0__MT__GDDR5 0x50000000 61 #define MC_SEQ_MISC0__MT__HBM 0x60000000 62 #define MC_SEQ_MISC0__MT__DDR3 0xB0000000 63 64 static int gmc_v6_0_init_microcode(struct amdgpu_device *adev) 65 { 66 const char *chip_name; 67 int err; 68 69 DRM_DEBUG("\n"); 70 71 switch (adev->asic_type) { 72 case CHIP_TAHITI: 73 chip_name = "tahiti"; 74 break; 75 case CHIP_PITCAIRN: 76 chip_name = "pitcairn"; 77 break; 78 case CHIP_VERDE: 79 chip_name = "verde"; 80 break; 81 case CHIP_OLAND: 82 chip_name = "oland"; 83 break; 84 case CHIP_HAINAN: 85 chip_name = "hainan"; 86 break; 87 default: 88 return -EINVAL; 89 } 90 91 /* this memory configuration requires special firmware */ 92 if (((RREG32(mmMC_SEQ_MISC0) & 0xff000000) >> 24) == 0x58) 93 chip_name = "si58"; 94 95 err = amdgpu_ucode_request(adev, &adev->gmc.fw, AMDGPU_UCODE_REQUIRED, 96 "amdgpu/%s_mc.bin", chip_name); 97 if (err) { 98 dev_err(adev->dev, 99 "si_mc: Failed to load firmware \"%s_mc.bin\"\n", 100 chip_name); 101 amdgpu_ucode_release(&adev->gmc.fw); 102 } 103 return err; 104 } 105 106 static int gmc_v6_0_mc_load_microcode(struct amdgpu_device *adev) 107 { 108 const __le32 *new_fw_data = NULL; 109 u32 running; 110 const __le32 *new_io_mc_regs = NULL; 111 int i, regs_size, ucode_size; 112 const struct mc_firmware_header_v1_0 *hdr; 113 114 if (!adev->gmc.fw) 115 return -EINVAL; 116 117 hdr = (const struct mc_firmware_header_v1_0 *)adev->gmc.fw->data; 118 119 amdgpu_ucode_print_mc_hdr(&hdr->header); 120 121 adev->gmc.fw_version = le32_to_cpu(hdr->header.ucode_version); 122 regs_size = le32_to_cpu(hdr->io_debug_size_bytes) / (4 * 2); 123 new_io_mc_regs = (const __le32 *) 124 (adev->gmc.fw->data + le32_to_cpu(hdr->io_debug_array_offset_bytes)); 125 ucode_size = le32_to_cpu(hdr->header.ucode_size_bytes) / 4; 126 new_fw_data = (const __le32 *) 127 (adev->gmc.fw->data + le32_to_cpu(hdr->header.ucode_array_offset_bytes)); 128 129 running = RREG32(mmMC_SEQ_SUP_CNTL) & MC_SEQ_SUP_CNTL__RUN_MASK; 130 131 if (running == 0) { 132 133 /* reset the engine and set to writable */ 134 WREG32(mmMC_SEQ_SUP_CNTL, 0x00000008); 135 WREG32(mmMC_SEQ_SUP_CNTL, 0x00000010); 136 137 /* load mc io regs */ 138 for (i = 0; i < regs_size; i++) { 139 WREG32(mmMC_SEQ_IO_DEBUG_INDEX, le32_to_cpup(new_io_mc_regs++)); 140 WREG32(mmMC_SEQ_IO_DEBUG_DATA, le32_to_cpup(new_io_mc_regs++)); 141 } 142 /* load the MC ucode */ 143 for (i = 0; i < ucode_size; i++) 144 WREG32(mmMC_SEQ_SUP_PGM, le32_to_cpup(new_fw_data++)); 145 146 /* put the engine back into the active state */ 147 WREG32(mmMC_SEQ_SUP_CNTL, 0x00000008); 148 WREG32(mmMC_SEQ_SUP_CNTL, 0x00000004); 149 WREG32(mmMC_SEQ_SUP_CNTL, 0x00000001); 150 151 /* wait for training to complete */ 152 for (i = 0; i < adev->usec_timeout; i++) { 153 if (RREG32(mmMC_SEQ_TRAIN_WAKEUP_CNTL) & MC_SEQ_TRAIN_WAKEUP_CNTL__TRAIN_DONE_D0_MASK) 154 break; 155 udelay(1); 156 } 157 for (i = 0; i < adev->usec_timeout; i++) { 158 if (RREG32(mmMC_SEQ_TRAIN_WAKEUP_CNTL) & MC_SEQ_TRAIN_WAKEUP_CNTL__TRAIN_DONE_D1_MASK) 159 break; 160 udelay(1); 161 } 162 163 } 164 165 return 0; 166 } 167 168 static void gmc_v6_0_vram_gtt_location(struct amdgpu_device *adev, 169 struct amdgpu_gmc *mc) 170 { 171 u64 base = RREG32(mmMC_VM_FB_LOCATION) & 0xFFFF; 172 173 base <<= 24; 174 175 amdgpu_gmc_set_agp_default(adev, mc); 176 amdgpu_gmc_vram_location(adev, mc, base); 177 amdgpu_gmc_gart_location(adev, mc, AMDGPU_GART_PLACEMENT_LOW); 178 } 179 180 static void gmc_v6_0_mc_program(struct amdgpu_device *adev) 181 { 182 int i, j; 183 struct amdgpu_ip_block *ip_block; 184 185 186 /* Initialize HDP */ 187 for (i = 0, j = 0; i < 32; i++, j += 0x6) { 188 WREG32((0xb05 + j), 0x00000000); 189 WREG32((0xb06 + j), 0x00000000); 190 WREG32((0xb07 + j), 0x00000000); 191 WREG32((0xb08 + j), 0x00000000); 192 WREG32((0xb09 + j), 0x00000000); 193 } 194 WREG32(mmHDP_REG_COHERENCY_FLUSH_CNTL, 0); 195 196 ip_block = amdgpu_device_ip_get_ip_block(adev, AMD_IP_BLOCK_TYPE_GMC); 197 if (!ip_block) 198 return; 199 200 if (gmc_v6_0_wait_for_idle(ip_block)) 201 dev_warn(adev->dev, "Wait for MC idle timedout !\n"); 202 203 if (adev->mode_info.num_crtc) { 204 u32 tmp; 205 206 /* Lockout access through VGA aperture*/ 207 tmp = RREG32(mmVGA_HDP_CONTROL); 208 tmp |= VGA_HDP_CONTROL__VGA_MEMORY_DISABLE_MASK; 209 WREG32(mmVGA_HDP_CONTROL, tmp); 210 211 /* disable VGA render */ 212 tmp = RREG32(mmVGA_RENDER_CONTROL); 213 tmp &= VGA_RENDER_CONTROL__VGA_VSTATUS_CNTL_MASK; 214 WREG32(mmVGA_RENDER_CONTROL, tmp); 215 } 216 /* Update configuration */ 217 WREG32(mmMC_VM_SYSTEM_APERTURE_LOW_ADDR, 218 adev->gmc.vram_start >> 12); 219 WREG32(mmMC_VM_SYSTEM_APERTURE_HIGH_ADDR, 220 adev->gmc.vram_end >> 12); 221 WREG32(mmMC_VM_SYSTEM_APERTURE_DEFAULT_ADDR, 222 adev->mem_scratch.gpu_addr >> 12); 223 WREG32(mmMC_VM_AGP_BASE, 0); 224 WREG32(mmMC_VM_AGP_TOP, adev->gmc.agp_end >> 22); 225 WREG32(mmMC_VM_AGP_BOT, adev->gmc.agp_start >> 22); 226 227 if (gmc_v6_0_wait_for_idle(ip_block)) 228 dev_warn(adev->dev, "Wait for MC idle timedout !\n"); 229 } 230 231 static int gmc_v6_0_mc_init(struct amdgpu_device *adev) 232 { 233 234 u32 tmp; 235 int chansize, numchan; 236 int r; 237 238 tmp = RREG32(mmMC_ARB_RAMCFG); 239 if (tmp & (1 << 11)) 240 chansize = 16; 241 else if (tmp & MC_ARB_RAMCFG__CHANSIZE_MASK) 242 chansize = 64; 243 else 244 chansize = 32; 245 246 tmp = RREG32(mmMC_SHARED_CHMAP); 247 switch ((tmp & MC_SHARED_CHMAP__NOOFCHAN_MASK) >> MC_SHARED_CHMAP__NOOFCHAN__SHIFT) { 248 case 0: 249 default: 250 numchan = 1; 251 break; 252 case 1: 253 numchan = 2; 254 break; 255 case 2: 256 numchan = 4; 257 break; 258 case 3: 259 numchan = 8; 260 break; 261 case 4: 262 numchan = 3; 263 break; 264 case 5: 265 numchan = 6; 266 break; 267 case 6: 268 numchan = 10; 269 break; 270 case 7: 271 numchan = 12; 272 break; 273 case 8: 274 numchan = 16; 275 break; 276 } 277 adev->gmc.vram_width = numchan * chansize; 278 /* size in MB on si */ 279 adev->gmc.mc_vram_size = RREG32(mmCONFIG_MEMSIZE) * 1024ULL * 1024ULL; 280 adev->gmc.real_vram_size = RREG32(mmCONFIG_MEMSIZE) * 1024ULL * 1024ULL; 281 282 if (!(adev->flags & AMD_IS_APU)) { 283 r = amdgpu_device_resize_fb_bar(adev); 284 if (r) 285 return r; 286 } 287 adev->gmc.aper_base = pci_resource_start(adev->pdev, 0); 288 adev->gmc.aper_size = pci_resource_len(adev->pdev, 0); 289 adev->gmc.visible_vram_size = adev->gmc.aper_size; 290 291 /* set the gart size */ 292 switch (adev->asic_type) { 293 case CHIP_VERDE: /* UVD, VCE do not support GPUVM */ 294 case CHIP_TAHITI: /* UVD, VCE do not support GPUVM */ 295 case CHIP_PITCAIRN: /* UVD, VCE do not support GPUVM */ 296 case CHIP_OLAND: /* UVD, VCE do not support GPUVM */ 297 amdgpu_gmc_set_gart_size(adev, SZ_1G); 298 break; 299 case CHIP_HAINAN: /* no MM engines */ 300 default: 301 amdgpu_gmc_set_gart_size(adev, SZ_256M); 302 break; 303 } 304 gmc_v6_0_vram_gtt_location(adev, &adev->gmc); 305 306 return 0; 307 } 308 309 static void gmc_v6_0_flush_gpu_tlb(struct amdgpu_device *adev, uint32_t vmid, 310 uint32_t vmhub, uint32_t flush_type) 311 { 312 WREG32(mmVM_INVALIDATE_REQUEST, 1 << vmid); 313 } 314 315 static uint64_t gmc_v6_0_emit_flush_gpu_tlb(struct amdgpu_ring *ring, 316 unsigned int vmid, uint64_t pd_addr) 317 { 318 uint32_t reg; 319 320 /* write new base address */ 321 if (vmid < 8) 322 reg = mmVM_CONTEXT0_PAGE_TABLE_BASE_ADDR + vmid; 323 else 324 reg = mmVM_CONTEXT8_PAGE_TABLE_BASE_ADDR + (vmid - 8); 325 amdgpu_ring_emit_wreg(ring, reg, pd_addr >> 12); 326 327 /* bits 0-15 are the VM contexts0-15 */ 328 amdgpu_ring_emit_wreg(ring, mmVM_INVALIDATE_REQUEST, 1 << vmid); 329 330 return pd_addr; 331 } 332 333 static void gmc_v6_0_get_vm_pde(struct amdgpu_device *adev, int level, 334 uint64_t *addr, uint64_t *flags) 335 { 336 BUG_ON(*addr & 0xFFFFFF0000000FFFULL); 337 } 338 339 static void gmc_v6_0_get_vm_pte(struct amdgpu_device *adev, 340 struct amdgpu_vm *vm, 341 struct amdgpu_bo *bo, 342 uint32_t vm_flags, 343 uint64_t *flags) 344 { 345 *flags &= ~AMDGPU_PTE_EXECUTABLE; 346 *flags &= ~AMDGPU_PTE_PRT; 347 } 348 349 static void gmc_v6_0_set_fault_enable_default(struct amdgpu_device *adev, 350 bool value) 351 { 352 u32 tmp; 353 354 tmp = RREG32(mmVM_CONTEXT1_CNTL); 355 tmp = REG_SET_FIELD(tmp, VM_CONTEXT1_CNTL, 356 RANGE_PROTECTION_FAULT_ENABLE_DEFAULT, value); 357 tmp = REG_SET_FIELD(tmp, VM_CONTEXT1_CNTL, 358 DUMMY_PAGE_PROTECTION_FAULT_ENABLE_DEFAULT, value); 359 tmp = REG_SET_FIELD(tmp, VM_CONTEXT1_CNTL, 360 PDE0_PROTECTION_FAULT_ENABLE_DEFAULT, value); 361 tmp = REG_SET_FIELD(tmp, VM_CONTEXT1_CNTL, 362 VALID_PROTECTION_FAULT_ENABLE_DEFAULT, value); 363 tmp = REG_SET_FIELD(tmp, VM_CONTEXT1_CNTL, 364 READ_PROTECTION_FAULT_ENABLE_DEFAULT, value); 365 tmp = REG_SET_FIELD(tmp, VM_CONTEXT1_CNTL, 366 WRITE_PROTECTION_FAULT_ENABLE_DEFAULT, value); 367 WREG32(mmVM_CONTEXT1_CNTL, tmp); 368 } 369 370 /** 371 * gmc_v8_0_set_prt() - set PRT VM fault 372 * 373 * @adev: amdgpu_device pointer 374 * @enable: enable/disable VM fault handling for PRT 375 */ 376 static void gmc_v6_0_set_prt(struct amdgpu_device *adev, bool enable) 377 { 378 u32 tmp; 379 380 if (enable && !adev->gmc.prt_warning) { 381 dev_warn(adev->dev, "Disabling VM faults because of PRT request!\n"); 382 adev->gmc.prt_warning = true; 383 } 384 385 tmp = RREG32(mmVM_PRT_CNTL); 386 tmp = REG_SET_FIELD(tmp, VM_PRT_CNTL, 387 CB_DISABLE_FAULT_ON_UNMAPPED_ACCESS, 388 enable); 389 tmp = REG_SET_FIELD(tmp, VM_PRT_CNTL, 390 TC_DISABLE_FAULT_ON_UNMAPPED_ACCESS, 391 enable); 392 tmp = REG_SET_FIELD(tmp, VM_PRT_CNTL, 393 L2_CACHE_STORE_INVALID_ENTRIES, 394 enable); 395 tmp = REG_SET_FIELD(tmp, VM_PRT_CNTL, 396 L1_TLB_STORE_INVALID_ENTRIES, 397 enable); 398 WREG32(mmVM_PRT_CNTL, tmp); 399 400 if (enable) { 401 uint32_t low = AMDGPU_VA_RESERVED_BOTTOM >> 402 AMDGPU_GPU_PAGE_SHIFT; 403 uint32_t high = adev->vm_manager.max_pfn - 404 (AMDGPU_VA_RESERVED_TOP >> AMDGPU_GPU_PAGE_SHIFT); 405 406 WREG32(mmVM_PRT_APERTURE0_LOW_ADDR, low); 407 WREG32(mmVM_PRT_APERTURE1_LOW_ADDR, low); 408 WREG32(mmVM_PRT_APERTURE2_LOW_ADDR, low); 409 WREG32(mmVM_PRT_APERTURE3_LOW_ADDR, low); 410 WREG32(mmVM_PRT_APERTURE0_HIGH_ADDR, high); 411 WREG32(mmVM_PRT_APERTURE1_HIGH_ADDR, high); 412 WREG32(mmVM_PRT_APERTURE2_HIGH_ADDR, high); 413 WREG32(mmVM_PRT_APERTURE3_HIGH_ADDR, high); 414 } else { 415 WREG32(mmVM_PRT_APERTURE0_LOW_ADDR, 0xfffffff); 416 WREG32(mmVM_PRT_APERTURE1_LOW_ADDR, 0xfffffff); 417 WREG32(mmVM_PRT_APERTURE2_LOW_ADDR, 0xfffffff); 418 WREG32(mmVM_PRT_APERTURE3_LOW_ADDR, 0xfffffff); 419 WREG32(mmVM_PRT_APERTURE0_HIGH_ADDR, 0x0); 420 WREG32(mmVM_PRT_APERTURE1_HIGH_ADDR, 0x0); 421 WREG32(mmVM_PRT_APERTURE2_HIGH_ADDR, 0x0); 422 WREG32(mmVM_PRT_APERTURE3_HIGH_ADDR, 0x0); 423 } 424 } 425 426 static int gmc_v6_0_gart_enable(struct amdgpu_device *adev) 427 { 428 uint64_t table_addr; 429 u32 field; 430 int i; 431 432 if (adev->gart.bo == NULL) { 433 dev_err(adev->dev, "No VRAM object for PCIE GART.\n"); 434 return -EINVAL; 435 } 436 amdgpu_gtt_mgr_recover(&adev->mman.gtt_mgr); 437 438 table_addr = amdgpu_bo_gpu_offset(adev->gart.bo); 439 440 /* Setup TLB control */ 441 WREG32(mmMC_VM_MX_L1_TLB_CNTL, 442 (0xA << 7) | 443 MC_VM_MX_L1_TLB_CNTL__ENABLE_L1_TLB_MASK | 444 MC_VM_MX_L1_TLB_CNTL__ENABLE_L1_FRAGMENT_PROCESSING_MASK | 445 MC_VM_MX_L1_TLB_CNTL__SYSTEM_ACCESS_MODE_MASK | 446 MC_VM_MX_L1_TLB_CNTL__ENABLE_ADVANCED_DRIVER_MODEL_MASK | 447 (0UL << MC_VM_MX_L1_TLB_CNTL__SYSTEM_APERTURE_UNMAPPED_ACCESS__SHIFT)); 448 /* Setup L2 cache */ 449 WREG32(mmVM_L2_CNTL, 450 VM_L2_CNTL__ENABLE_L2_CACHE_MASK | 451 VM_L2_CNTL__ENABLE_L2_FRAGMENT_PROCESSING_MASK | 452 VM_L2_CNTL__ENABLE_L2_PTE_CACHE_LRU_UPDATE_BY_WRITE_MASK | 453 VM_L2_CNTL__ENABLE_L2_PDE0_CACHE_LRU_UPDATE_BY_WRITE_MASK | 454 (7UL << VM_L2_CNTL__EFFECTIVE_L2_QUEUE_SIZE__SHIFT) | 455 (1UL << VM_L2_CNTL__CONTEXT1_IDENTITY_ACCESS_MODE__SHIFT)); 456 WREG32(mmVM_L2_CNTL2, 457 VM_L2_CNTL2__INVALIDATE_ALL_L1_TLBS_MASK | 458 VM_L2_CNTL2__INVALIDATE_L2_CACHE_MASK); 459 460 field = adev->vm_manager.fragment_size; 461 WREG32(mmVM_L2_CNTL3, 462 VM_L2_CNTL3__L2_CACHE_BIGK_ASSOCIATIVITY_MASK | 463 (field << VM_L2_CNTL3__BANK_SELECT__SHIFT) | 464 (field << VM_L2_CNTL3__L2_CACHE_BIGK_FRAGMENT_SIZE__SHIFT)); 465 /* setup context0 */ 466 WREG32(mmVM_CONTEXT0_PAGE_TABLE_START_ADDR, adev->gmc.gart_start >> 12); 467 WREG32(mmVM_CONTEXT0_PAGE_TABLE_END_ADDR, adev->gmc.gart_end >> 12); 468 WREG32(mmVM_CONTEXT0_PAGE_TABLE_BASE_ADDR, table_addr >> 12); 469 WREG32(mmVM_CONTEXT0_PROTECTION_FAULT_DEFAULT_ADDR, 470 (u32)(adev->dummy_page_addr >> 12)); 471 WREG32(mmVM_CONTEXT0_CNTL2, 0); 472 WREG32(mmVM_CONTEXT0_CNTL, 473 VM_CONTEXT0_CNTL__ENABLE_CONTEXT_MASK | 474 (0UL << VM_CONTEXT0_CNTL__PAGE_TABLE_DEPTH__SHIFT) | 475 VM_CONTEXT0_CNTL__RANGE_PROTECTION_FAULT_ENABLE_DEFAULT_MASK); 476 477 WREG32(0x575, 0); 478 WREG32(0x576, 0); 479 WREG32(0x577, 0); 480 481 /* empty context1-15 */ 482 /* set vm size, must be a multiple of 4 */ 483 WREG32(mmVM_CONTEXT1_PAGE_TABLE_START_ADDR, 0); 484 WREG32(mmVM_CONTEXT1_PAGE_TABLE_END_ADDR, adev->vm_manager.max_pfn - 1); 485 /* Assign the pt base to something valid for now; the pts used for 486 * the VMs are determined by the application and setup and assigned 487 * on the fly in the vm part of radeon_gart.c 488 */ 489 for (i = 1; i < AMDGPU_NUM_VMID; i++) { 490 if (i < 8) 491 WREG32(mmVM_CONTEXT0_PAGE_TABLE_BASE_ADDR + i, 492 table_addr >> 12); 493 else 494 WREG32(mmVM_CONTEXT8_PAGE_TABLE_BASE_ADDR + i - 8, 495 table_addr >> 12); 496 } 497 498 /* enable context1-15 */ 499 WREG32(mmVM_CONTEXT1_PROTECTION_FAULT_DEFAULT_ADDR, 500 (u32)(adev->dummy_page_addr >> 12)); 501 WREG32(mmVM_CONTEXT1_CNTL2, 4); 502 WREG32(mmVM_CONTEXT1_CNTL, 503 VM_CONTEXT1_CNTL__ENABLE_CONTEXT_MASK | 504 (1UL << VM_CONTEXT1_CNTL__PAGE_TABLE_DEPTH__SHIFT) | 505 ((adev->vm_manager.block_size - 9) 506 << VM_CONTEXT1_CNTL__PAGE_TABLE_BLOCK_SIZE__SHIFT)); 507 if (amdgpu_vm_fault_stop == AMDGPU_VM_FAULT_STOP_ALWAYS) 508 gmc_v6_0_set_fault_enable_default(adev, false); 509 else 510 gmc_v6_0_set_fault_enable_default(adev, true); 511 512 gmc_v6_0_flush_gpu_tlb(adev, 0, 0, 0); 513 drm_info(adev_to_drm(adev), "PCIE GART of %uM enabled (table at 0x%016llX).\n", 514 (unsigned int)(adev->gmc.gart_size >> 20), 515 (unsigned long long)table_addr); 516 return 0; 517 } 518 519 static int gmc_v6_0_gart_init(struct amdgpu_device *adev) 520 { 521 int r; 522 523 if (adev->gart.bo) { 524 dev_warn(adev->dev, "gmc_v6_0 PCIE GART already initialized\n"); 525 return 0; 526 } 527 r = amdgpu_gart_init(adev); 528 if (r) 529 return r; 530 adev->gart.table_size = adev->gart.num_gpu_pages * 8; 531 adev->gart.gart_pte_flags = 0; 532 return amdgpu_gart_table_vram_alloc(adev); 533 } 534 535 static void gmc_v6_0_gart_disable(struct amdgpu_device *adev) 536 { 537 /*unsigned i; 538 539 for (i = 1; i < 16; ++i) { 540 uint32_t reg; 541 if (i < 8) 542 reg = VM_CONTEXT0_PAGE_TABLE_BASE_ADDR + i ; 543 else 544 reg = VM_CONTEXT8_PAGE_TABLE_BASE_ADDR + (i - 8); 545 adev->vm_manager.saved_table_addr[i] = RREG32(reg); 546 }*/ 547 548 /* Disable all tables */ 549 WREG32(mmVM_CONTEXT0_CNTL, 0); 550 WREG32(mmVM_CONTEXT1_CNTL, 0); 551 /* Setup TLB control */ 552 WREG32(mmMC_VM_MX_L1_TLB_CNTL, 553 MC_VM_MX_L1_TLB_CNTL__SYSTEM_ACCESS_MODE_MASK | 554 (0UL << MC_VM_MX_L1_TLB_CNTL__SYSTEM_APERTURE_UNMAPPED_ACCESS__SHIFT)); 555 /* Setup L2 cache */ 556 WREG32(mmVM_L2_CNTL, 557 VM_L2_CNTL__ENABLE_L2_PTE_CACHE_LRU_UPDATE_BY_WRITE_MASK | 558 VM_L2_CNTL__ENABLE_L2_PDE0_CACHE_LRU_UPDATE_BY_WRITE_MASK | 559 (7UL << VM_L2_CNTL__EFFECTIVE_L2_QUEUE_SIZE__SHIFT) | 560 (1UL << VM_L2_CNTL__CONTEXT1_IDENTITY_ACCESS_MODE__SHIFT)); 561 WREG32(mmVM_L2_CNTL2, 0); 562 WREG32(mmVM_L2_CNTL3, 563 VM_L2_CNTL3__L2_CACHE_BIGK_ASSOCIATIVITY_MASK | 564 (0UL << VM_L2_CNTL3__L2_CACHE_BIGK_FRAGMENT_SIZE__SHIFT)); 565 } 566 567 static void gmc_v6_0_vm_decode_fault(struct amdgpu_device *adev, 568 u32 status, u32 addr) 569 { 570 u32 mc_id; 571 u32 vmid = REG_GET_FIELD(status, VM_CONTEXT1_PROTECTION_FAULT_STATUS, VMID); 572 u32 protections = REG_GET_FIELD(status, VM_CONTEXT1_PROTECTION_FAULT_STATUS, 573 PROTECTIONS); 574 575 mc_id = REG_GET_FIELD(status, VM_CONTEXT1_PROTECTION_FAULT_STATUS, 576 MEMORY_CLIENT_ID); 577 578 dev_err(adev->dev, "VM fault (0x%02x, vmid %d) at page %u, %s from %d\n", 579 protections, vmid, addr, 580 REG_GET_FIELD(status, VM_CONTEXT1_PROTECTION_FAULT_STATUS, 581 MEMORY_CLIENT_RW) ? 582 "write" : "read", mc_id); 583 } 584 585 static const u32 mc_cg_registers[] = { 586 mmMC_HUB_MISC_HUB_CG, 587 mmMC_HUB_MISC_SIP_CG, 588 mmMC_HUB_MISC_VM_CG, 589 mmMC_XPB_CLK_GAT, 590 mmATC_MISC_CG, 591 mmMC_CITF_MISC_WR_CG, 592 mmMC_CITF_MISC_RD_CG, 593 mmMC_CITF_MISC_VM_CG, 594 mmVM_L2_CG, 595 }; 596 597 static const u32 mc_cg_ls_en[] = { 598 MC_HUB_MISC_HUB_CG__MEM_LS_ENABLE_MASK, 599 MC_HUB_MISC_SIP_CG__MEM_LS_ENABLE_MASK, 600 MC_HUB_MISC_VM_CG__MEM_LS_ENABLE_MASK, 601 MC_XPB_CLK_GAT__MEM_LS_ENABLE_MASK, 602 ATC_MISC_CG__MEM_LS_ENABLE_MASK, 603 MC_CITF_MISC_WR_CG__MEM_LS_ENABLE_MASK, 604 MC_CITF_MISC_RD_CG__MEM_LS_ENABLE_MASK, 605 MC_CITF_MISC_VM_CG__MEM_LS_ENABLE_MASK, 606 VM_L2_CG__MEM_LS_ENABLE_MASK, 607 }; 608 609 static const u32 mc_cg_en[] = { 610 MC_HUB_MISC_HUB_CG__ENABLE_MASK, 611 MC_HUB_MISC_SIP_CG__ENABLE_MASK, 612 MC_HUB_MISC_VM_CG__ENABLE_MASK, 613 MC_XPB_CLK_GAT__ENABLE_MASK, 614 ATC_MISC_CG__ENABLE_MASK, 615 MC_CITF_MISC_WR_CG__ENABLE_MASK, 616 MC_CITF_MISC_RD_CG__ENABLE_MASK, 617 MC_CITF_MISC_VM_CG__ENABLE_MASK, 618 VM_L2_CG__ENABLE_MASK, 619 }; 620 621 static void gmc_v6_0_enable_mc_ls(struct amdgpu_device *adev, 622 bool enable) 623 { 624 int i; 625 u32 orig, data; 626 627 for (i = 0; i < ARRAY_SIZE(mc_cg_registers); i++) { 628 orig = data = RREG32(mc_cg_registers[i]); 629 if (enable && (adev->cg_flags & AMD_CG_SUPPORT_MC_LS)) 630 data |= mc_cg_ls_en[i]; 631 else 632 data &= ~mc_cg_ls_en[i]; 633 if (data != orig) 634 WREG32(mc_cg_registers[i], data); 635 } 636 } 637 638 static void gmc_v6_0_enable_mc_mgcg(struct amdgpu_device *adev, 639 bool enable) 640 { 641 int i; 642 u32 orig, data; 643 644 for (i = 0; i < ARRAY_SIZE(mc_cg_registers); i++) { 645 orig = data = RREG32(mc_cg_registers[i]); 646 if (enable && (adev->cg_flags & AMD_CG_SUPPORT_MC_MGCG)) 647 data |= mc_cg_en[i]; 648 else 649 data &= ~mc_cg_en[i]; 650 if (data != orig) 651 WREG32(mc_cg_registers[i], data); 652 } 653 } 654 655 static void gmc_v6_0_enable_bif_mgls(struct amdgpu_device *adev, 656 bool enable) 657 { 658 u32 orig, data; 659 660 orig = data = RREG32_PCIE(ixPCIE_CNTL2); 661 662 if (enable && (adev->cg_flags & AMD_CG_SUPPORT_BIF_LS)) { 663 data = REG_SET_FIELD(data, PCIE_CNTL2, SLV_MEM_LS_EN, 1); 664 data = REG_SET_FIELD(data, PCIE_CNTL2, MST_MEM_LS_EN, 1); 665 data = REG_SET_FIELD(data, PCIE_CNTL2, REPLAY_MEM_LS_EN, 1); 666 data = REG_SET_FIELD(data, PCIE_CNTL2, SLV_MEM_AGGRESSIVE_LS_EN, 1); 667 } else { 668 data = REG_SET_FIELD(data, PCIE_CNTL2, SLV_MEM_LS_EN, 0); 669 data = REG_SET_FIELD(data, PCIE_CNTL2, MST_MEM_LS_EN, 0); 670 data = REG_SET_FIELD(data, PCIE_CNTL2, REPLAY_MEM_LS_EN, 0); 671 data = REG_SET_FIELD(data, PCIE_CNTL2, SLV_MEM_AGGRESSIVE_LS_EN, 0); 672 } 673 674 if (orig != data) 675 WREG32_PCIE(ixPCIE_CNTL2, data); 676 } 677 678 static void gmc_v6_0_enable_hdp_mgcg(struct amdgpu_device *adev, 679 bool enable) 680 { 681 u32 orig, data; 682 683 orig = data = RREG32(mmHDP_HOST_PATH_CNTL); 684 685 if (enable && (adev->cg_flags & AMD_CG_SUPPORT_HDP_MGCG)) 686 data = REG_SET_FIELD(data, HDP_HOST_PATH_CNTL, CLOCK_GATING_DIS, 0); 687 else 688 data = REG_SET_FIELD(data, HDP_HOST_PATH_CNTL, CLOCK_GATING_DIS, 1); 689 690 if (orig != data) 691 WREG32(mmHDP_HOST_PATH_CNTL, data); 692 } 693 694 static void gmc_v6_0_enable_hdp_ls(struct amdgpu_device *adev, 695 bool enable) 696 { 697 u32 orig, data; 698 699 orig = data = RREG32(mmHDP_MEM_POWER_LS); 700 701 if (enable && (adev->cg_flags & AMD_CG_SUPPORT_HDP_LS)) 702 data = REG_SET_FIELD(data, HDP_MEM_POWER_LS, LS_ENABLE, 1); 703 else 704 data = REG_SET_FIELD(data, HDP_MEM_POWER_LS, LS_ENABLE, 0); 705 706 if (orig != data) 707 WREG32(mmHDP_MEM_POWER_LS, data); 708 } 709 710 static int gmc_v6_0_convert_vram_type(int mc_seq_vram_type) 711 { 712 switch (mc_seq_vram_type) { 713 case MC_SEQ_MISC0__MT__GDDR1: 714 return AMDGPU_VRAM_TYPE_GDDR1; 715 case MC_SEQ_MISC0__MT__DDR2: 716 return AMDGPU_VRAM_TYPE_DDR2; 717 case MC_SEQ_MISC0__MT__GDDR3: 718 return AMDGPU_VRAM_TYPE_GDDR3; 719 case MC_SEQ_MISC0__MT__GDDR4: 720 return AMDGPU_VRAM_TYPE_GDDR4; 721 case MC_SEQ_MISC0__MT__GDDR5: 722 return AMDGPU_VRAM_TYPE_GDDR5; 723 case MC_SEQ_MISC0__MT__DDR3: 724 return AMDGPU_VRAM_TYPE_DDR3; 725 default: 726 return AMDGPU_VRAM_TYPE_UNKNOWN; 727 } 728 } 729 730 static int gmc_v6_0_early_init(struct amdgpu_ip_block *ip_block) 731 { 732 struct amdgpu_device *adev = ip_block->adev; 733 734 gmc_v6_0_set_gmc_funcs(adev); 735 gmc_v6_0_set_irq_funcs(adev); 736 737 return 0; 738 } 739 740 static int gmc_v6_0_late_init(struct amdgpu_ip_block *ip_block) 741 { 742 struct amdgpu_device *adev = ip_block->adev; 743 744 if (amdgpu_vm_fault_stop != AMDGPU_VM_FAULT_STOP_ALWAYS) 745 return amdgpu_irq_get(adev, &adev->gmc.vm_fault, 0); 746 else 747 return 0; 748 } 749 750 static unsigned int gmc_v6_0_get_vbios_fb_size(struct amdgpu_device *adev) 751 { 752 u32 d1vga_control = RREG32(mmD1VGA_CONTROL); 753 unsigned int size; 754 755 if (REG_GET_FIELD(d1vga_control, D1VGA_CONTROL, D1VGA_MODE_ENABLE)) { 756 size = AMDGPU_VBIOS_VGA_ALLOCATION; 757 } else { 758 u32 viewport = RREG32(mmVIEWPORT_SIZE); 759 760 size = (REG_GET_FIELD(viewport, VIEWPORT_SIZE, VIEWPORT_HEIGHT) * 761 REG_GET_FIELD(viewport, VIEWPORT_SIZE, VIEWPORT_WIDTH) * 762 4); 763 } 764 return size; 765 } 766 767 static int gmc_v6_0_sw_init(struct amdgpu_ip_block *ip_block) 768 { 769 int r; 770 struct amdgpu_device *adev = ip_block->adev; 771 772 set_bit(AMDGPU_GFXHUB(0), adev->vmhubs_mask); 773 774 if (adev->flags & AMD_IS_APU) { 775 adev->gmc.vram_type = AMDGPU_VRAM_TYPE_UNKNOWN; 776 } else { 777 u32 tmp = RREG32(mmMC_SEQ_MISC0); 778 779 tmp &= MC_SEQ_MISC0__MT__MASK; 780 adev->gmc.vram_type = gmc_v6_0_convert_vram_type(tmp); 781 } 782 783 r = amdgpu_irq_add_id(adev, AMDGPU_IRQ_CLIENTID_LEGACY, 146, &adev->gmc.vm_fault); 784 if (r) 785 return r; 786 787 r = amdgpu_irq_add_id(adev, AMDGPU_IRQ_CLIENTID_LEGACY, 147, &adev->gmc.vm_fault); 788 if (r) 789 return r; 790 791 amdgpu_vm_adjust_size(adev, 64, 9, 1, 40); 792 793 adev->gmc.mc_mask = 0xffffffffffULL; 794 adev->gmc.pte_addr_mask = 0x000000FFFFFFF000ULL; 795 796 r = dma_set_mask_and_coherent(adev->dev, DMA_BIT_MASK(40)); 797 if (r) { 798 dev_warn(adev->dev, "No suitable DMA available.\n"); 799 return r; 800 } 801 adev->need_swiotlb = drm_need_swiotlb(40); 802 803 r = gmc_v6_0_init_microcode(adev); 804 if (r) { 805 dev_err(adev->dev, "Failed to load mc firmware!\n"); 806 return r; 807 } 808 809 r = gmc_v6_0_mc_init(adev); 810 if (r) 811 return r; 812 813 r = amdgpu_bo_init(adev); 814 if (r) 815 return r; 816 817 r = gmc_v6_0_gart_init(adev); 818 if (r) 819 return r; 820 821 /* 822 * number of VMs 823 * VMID 0 is reserved for System 824 * amdgpu graphics/compute will use VMIDs 1-7 825 * amdkfd will use VMIDs 8-15 826 */ 827 adev->vm_manager.first_kfd_vmid = 8; 828 amdgpu_vmid_mgr_set_vmid_mask(adev, 829 GENMASK(adev->vm_manager.first_kfd_vmid - 1, 1), 830 false); 831 amdgpu_vmid_mgr_set_vmid_mask(adev, 832 GENMASK(adev->vm_manager.first_kfd_vmid - 1, 1), 833 true); 834 amdgpu_vm_manager_init(adev); 835 836 /* base offset of vram pages */ 837 if (adev->flags & AMD_IS_APU) { 838 u64 tmp = RREG32(mmMC_VM_FB_OFFSET); 839 840 tmp <<= 22; 841 adev->vm_manager.vram_base_offset = tmp; 842 } else { 843 adev->vm_manager.vram_base_offset = 0; 844 } 845 846 return 0; 847 } 848 849 static int gmc_v6_0_sw_fini(struct amdgpu_ip_block *ip_block) 850 { 851 struct amdgpu_device *adev = ip_block->adev; 852 853 amdgpu_gem_force_release(adev); 854 amdgpu_vm_manager_fini(adev); 855 amdgpu_gart_table_vram_free(adev); 856 amdgpu_bo_fini(adev); 857 amdgpu_ucode_release(&adev->gmc.fw); 858 859 return 0; 860 } 861 862 static int gmc_v6_0_hw_init(struct amdgpu_ip_block *ip_block) 863 { 864 int r; 865 struct amdgpu_device *adev = ip_block->adev; 866 867 gmc_v6_0_mc_program(adev); 868 869 if (!(adev->flags & AMD_IS_APU)) { 870 r = gmc_v6_0_mc_load_microcode(adev); 871 if (r) { 872 dev_err(adev->dev, "Failed to load MC firmware!\n"); 873 return r; 874 } 875 } 876 877 r = gmc_v6_0_gart_enable(adev); 878 if (r) 879 return r; 880 881 if (amdgpu_emu_mode == 1) 882 return amdgpu_gmc_vram_checking(adev); 883 884 return 0; 885 } 886 887 static int gmc_v6_0_hw_fini(struct amdgpu_ip_block *ip_block) 888 { 889 struct amdgpu_device *adev = ip_block->adev; 890 891 amdgpu_irq_put(adev, &adev->gmc.vm_fault, 0); 892 gmc_v6_0_gart_disable(adev); 893 894 return 0; 895 } 896 897 static int gmc_v6_0_suspend(struct amdgpu_ip_block *ip_block) 898 { 899 gmc_v6_0_hw_fini(ip_block); 900 901 return 0; 902 } 903 904 static int gmc_v6_0_resume(struct amdgpu_ip_block *ip_block) 905 { 906 int r; 907 struct amdgpu_device *adev = ip_block->adev; 908 909 r = gmc_v6_0_hw_init(ip_block); 910 if (r) 911 return r; 912 913 amdgpu_vmid_reset_all(adev); 914 915 return 0; 916 } 917 918 static bool gmc_v6_0_is_idle(struct amdgpu_ip_block *ip_block) 919 { 920 struct amdgpu_device *adev = ip_block->adev; 921 922 u32 tmp = RREG32(mmSRBM_STATUS); 923 924 if (tmp & (SRBM_STATUS__MCB_BUSY_MASK | SRBM_STATUS__MCB_NON_DISPLAY_BUSY_MASK | 925 SRBM_STATUS__MCC_BUSY_MASK | SRBM_STATUS__MCD_BUSY_MASK | SRBM_STATUS__VMC_BUSY_MASK)) 926 return false; 927 928 return true; 929 } 930 931 static int gmc_v6_0_wait_for_idle(struct amdgpu_ip_block *ip_block) 932 { 933 unsigned int i; 934 struct amdgpu_device *adev = ip_block->adev; 935 936 for (i = 0; i < adev->usec_timeout; i++) { 937 if (gmc_v6_0_is_idle(ip_block)) 938 return 0; 939 udelay(1); 940 } 941 return -ETIMEDOUT; 942 943 } 944 945 static int gmc_v6_0_vm_fault_interrupt_state(struct amdgpu_device *adev, 946 struct amdgpu_irq_src *src, 947 unsigned int type, 948 enum amdgpu_interrupt_state state) 949 { 950 u32 tmp; 951 u32 bits = (VM_CONTEXT1_CNTL__RANGE_PROTECTION_FAULT_ENABLE_INTERRUPT_MASK | 952 VM_CONTEXT1_CNTL__DUMMY_PAGE_PROTECTION_FAULT_ENABLE_INTERRUPT_MASK | 953 VM_CONTEXT1_CNTL__PDE0_PROTECTION_FAULT_ENABLE_INTERRUPT_MASK | 954 VM_CONTEXT1_CNTL__VALID_PROTECTION_FAULT_ENABLE_INTERRUPT_MASK | 955 VM_CONTEXT1_CNTL__READ_PROTECTION_FAULT_ENABLE_INTERRUPT_MASK | 956 VM_CONTEXT1_CNTL__WRITE_PROTECTION_FAULT_ENABLE_INTERRUPT_MASK); 957 958 switch (state) { 959 case AMDGPU_IRQ_STATE_DISABLE: 960 tmp = RREG32(mmVM_CONTEXT0_CNTL); 961 tmp &= ~bits; 962 WREG32(mmVM_CONTEXT0_CNTL, tmp); 963 tmp = RREG32(mmVM_CONTEXT1_CNTL); 964 tmp &= ~bits; 965 WREG32(mmVM_CONTEXT1_CNTL, tmp); 966 break; 967 case AMDGPU_IRQ_STATE_ENABLE: 968 tmp = RREG32(mmVM_CONTEXT0_CNTL); 969 tmp |= bits; 970 WREG32(mmVM_CONTEXT0_CNTL, tmp); 971 tmp = RREG32(mmVM_CONTEXT1_CNTL); 972 tmp |= bits; 973 WREG32(mmVM_CONTEXT1_CNTL, tmp); 974 break; 975 default: 976 break; 977 } 978 979 return 0; 980 } 981 982 static int gmc_v6_0_process_interrupt(struct amdgpu_device *adev, 983 struct amdgpu_irq_src *source, 984 struct amdgpu_iv_entry *entry) 985 { 986 u32 addr, status; 987 988 /* Delegate to the soft IRQ handler ring */ 989 if (adev->irq.ih_soft.enabled && entry->ih != &adev->irq.ih_soft) { 990 amdgpu_irq_delegate(adev, entry, 4); 991 return 1; 992 } 993 994 addr = RREG32(mmVM_CONTEXT1_PROTECTION_FAULT_ADDR); 995 status = RREG32(mmVM_CONTEXT1_PROTECTION_FAULT_STATUS); 996 WREG32_P(mmVM_CONTEXT1_CNTL2, 1, ~1); 997 998 if (!addr && !status) 999 return 0; 1000 1001 amdgpu_vm_update_fault_cache(adev, entry->pasid, 1002 ((u64)addr) << AMDGPU_GPU_PAGE_SHIFT, 1003 status, AMDGPU_GFXHUB(0)); 1004 1005 if (amdgpu_vm_fault_stop == AMDGPU_VM_FAULT_STOP_FIRST) 1006 gmc_v6_0_set_fault_enable_default(adev, false); 1007 1008 if (printk_ratelimit()) { 1009 dev_err(adev->dev, "GPU fault detected: %d 0x%08x\n", 1010 entry->src_id, entry->src_data[0]); 1011 dev_err(adev->dev, " VM_CONTEXT1_PROTECTION_FAULT_ADDR 0x%08X\n", 1012 addr); 1013 dev_err(adev->dev, " VM_CONTEXT1_PROTECTION_FAULT_STATUS 0x%08X\n", 1014 status); 1015 gmc_v6_0_vm_decode_fault(adev, status, addr); 1016 } 1017 1018 return 0; 1019 } 1020 1021 static int gmc_v6_0_set_clockgating_state(struct amdgpu_ip_block *ip_block, 1022 enum amd_clockgating_state state) 1023 { 1024 struct amdgpu_device *adev = ip_block->adev; 1025 bool gate = false; 1026 1027 if (state == AMD_CG_STATE_GATE) 1028 gate = true; 1029 1030 if (!(adev->flags & AMD_IS_APU)) { 1031 gmc_v6_0_enable_mc_mgcg(adev, gate); 1032 gmc_v6_0_enable_mc_ls(adev, gate); 1033 } 1034 gmc_v6_0_enable_bif_mgls(adev, gate); 1035 gmc_v6_0_enable_hdp_mgcg(adev, gate); 1036 gmc_v6_0_enable_hdp_ls(adev, gate); 1037 1038 return 0; 1039 } 1040 1041 static int gmc_v6_0_set_powergating_state(struct amdgpu_ip_block *ip_block, 1042 enum amd_powergating_state state) 1043 { 1044 return 0; 1045 } 1046 1047 static const struct amd_ip_funcs gmc_v6_0_ip_funcs = { 1048 .name = "gmc_v6_0", 1049 .early_init = gmc_v6_0_early_init, 1050 .late_init = gmc_v6_0_late_init, 1051 .sw_init = gmc_v6_0_sw_init, 1052 .sw_fini = gmc_v6_0_sw_fini, 1053 .hw_init = gmc_v6_0_hw_init, 1054 .hw_fini = gmc_v6_0_hw_fini, 1055 .suspend = gmc_v6_0_suspend, 1056 .resume = gmc_v6_0_resume, 1057 .wait_for_idle = gmc_v6_0_wait_for_idle, 1058 .set_clockgating_state = gmc_v6_0_set_clockgating_state, 1059 .set_powergating_state = gmc_v6_0_set_powergating_state, 1060 }; 1061 1062 static const struct amdgpu_gmc_funcs gmc_v6_0_gmc_funcs = { 1063 .flush_gpu_tlb = gmc_v6_0_flush_gpu_tlb, 1064 .emit_flush_gpu_tlb = gmc_v6_0_emit_flush_gpu_tlb, 1065 .set_prt = gmc_v6_0_set_prt, 1066 .get_vm_pde = gmc_v6_0_get_vm_pde, 1067 .get_vm_pte = gmc_v6_0_get_vm_pte, 1068 .get_vbios_fb_size = gmc_v6_0_get_vbios_fb_size, 1069 }; 1070 1071 static const struct amdgpu_irq_src_funcs gmc_v6_0_irq_funcs = { 1072 .set = gmc_v6_0_vm_fault_interrupt_state, 1073 .process = gmc_v6_0_process_interrupt, 1074 }; 1075 1076 static void gmc_v6_0_set_gmc_funcs(struct amdgpu_device *adev) 1077 { 1078 adev->gmc.gmc_funcs = &gmc_v6_0_gmc_funcs; 1079 } 1080 1081 static void gmc_v6_0_set_irq_funcs(struct amdgpu_device *adev) 1082 { 1083 adev->gmc.vm_fault.num_types = 1; 1084 adev->gmc.vm_fault.funcs = &gmc_v6_0_irq_funcs; 1085 } 1086 1087 const struct amdgpu_ip_block_version gmc_v6_0_ip_block = { 1088 .type = AMD_IP_BLOCK_TYPE_GMC, 1089 .major = 6, 1090 .minor = 0, 1091 .rev = 0, 1092 .funcs = &gmc_v6_0_ip_funcs, 1093 }; 1094