1 /* 2 * Copyright 2008 Advanced Micro Devices, Inc. 3 * Copyright 2008 Red Hat Inc. 4 * Copyright 2009 Jerome Glisse. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the "Software"), 8 * to deal in the Software without restriction, including without limitation 9 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 * and/or sell copies of the Software, and to permit persons to whom the 11 * Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 * OTHER DEALINGS IN THE SOFTWARE. 23 * 24 * Authors: Dave Airlie 25 * Alex Deucher 26 * Jerome Glisse 27 */ 28 29 #include "amdgpu.h" 30 #include <drm/amdgpu_drm.h> 31 #include <drm/clients/drm_fbdev_helper.h> 32 #include <drm/drm_drv.h> 33 #include <drm/drm_vblank.h> 34 #include "amdgpu_uvd.h" 35 #include "amdgpu_vce.h" 36 #include "atom.h" 37 38 #include <linux/vga_switcheroo.h> 39 #include <linux/slab.h> 40 #include <linux/uaccess.h> 41 #include <linux/pci.h> 42 #include <linux/pm_runtime.h> 43 #include "amdgpu_amdkfd.h" 44 #include "amdgpu_gem.h" 45 #include "amdgpu_display.h" 46 #include "amdgpu_ras.h" 47 #include "amdgpu_reset.h" 48 #include "amd_pcie.h" 49 #include "amdgpu_userq.h" 50 #include "amdgpu_video_codecs.h" 51 #include "amdgpu_ras_mgr.h" 52 53 void amdgpu_unregister_gpu_instance(struct amdgpu_device *adev) 54 { 55 struct amdgpu_gpu_instance *gpu_instance; 56 int i; 57 58 mutex_lock(&mgpu_info.mutex); 59 60 for (i = 0; i < mgpu_info.num_gpu; i++) { 61 gpu_instance = &(mgpu_info.gpu_ins[i]); 62 if (gpu_instance->adev == adev) { 63 mgpu_info.gpu_ins[i] = 64 mgpu_info.gpu_ins[mgpu_info.num_gpu - 1]; 65 mgpu_info.num_gpu--; 66 if (adev->flags & AMD_IS_APU) 67 mgpu_info.num_apu--; 68 else 69 mgpu_info.num_dgpu--; 70 break; 71 } 72 } 73 74 mutex_unlock(&mgpu_info.mutex); 75 } 76 77 /** 78 * amdgpu_driver_unload_kms - Main unload function for KMS. 79 * 80 * @dev: drm dev pointer 81 * 82 * This is the main unload function for KMS (all asics). 83 * Returns 0 on success. 84 */ 85 void amdgpu_driver_unload_kms(struct drm_device *dev) 86 { 87 struct amdgpu_device *adev = drm_to_adev(dev); 88 89 if (adev == NULL || !adev->num_ip_blocks) 90 return; 91 92 amdgpu_unregister_gpu_instance(adev); 93 94 if (adev->rmmio == NULL) 95 return; 96 97 if (amdgpu_acpi_smart_shift_update(adev, AMDGPU_SS_DRV_UNLOAD)) 98 drm_warn(dev, "smart shift update failed\n"); 99 100 amdgpu_acpi_fini(adev); 101 amdgpu_device_fini_hw(adev); 102 } 103 104 void amdgpu_register_gpu_instance(struct amdgpu_device *adev) 105 { 106 struct amdgpu_gpu_instance *gpu_instance; 107 108 mutex_lock(&mgpu_info.mutex); 109 110 if (mgpu_info.num_gpu >= MAX_GPU_INSTANCE) { 111 drm_err(adev_to_drm(adev), "Cannot register more gpu instance\n"); 112 mutex_unlock(&mgpu_info.mutex); 113 return; 114 } 115 116 gpu_instance = &(mgpu_info.gpu_ins[mgpu_info.num_gpu]); 117 gpu_instance->adev = adev; 118 gpu_instance->mgpu_fan_enabled = 0; 119 120 mgpu_info.num_gpu++; 121 if (adev->flags & AMD_IS_APU) 122 mgpu_info.num_apu++; 123 else 124 mgpu_info.num_dgpu++; 125 126 mutex_unlock(&mgpu_info.mutex); 127 } 128 129 /** 130 * amdgpu_driver_load_kms - Main load function for KMS. 131 * 132 * @adev: pointer to struct amdgpu_device 133 * @flags: device flags 134 * 135 * This is the main load function for KMS (all asics). 136 * Returns 0 on success, error on failure. 137 */ 138 int amdgpu_driver_load_kms(struct amdgpu_device *adev, unsigned long flags) 139 { 140 struct drm_device *dev; 141 int r, acpi_status; 142 143 dev = adev_to_drm(adev); 144 145 /* amdgpu_device_init should report only fatal error 146 * like memory allocation failure or iomapping failure, 147 * or memory manager initialization failure, it must 148 * properly initialize the GPU MC controller and permit 149 * VRAM allocation 150 */ 151 r = amdgpu_device_init(adev, flags); 152 if (r) { 153 dev_err(dev->dev, "Fatal error during GPU init\n"); 154 goto out; 155 } 156 157 amdgpu_device_detect_runtime_pm_mode(adev); 158 159 /* Call ACPI methods: require modeset init 160 * but failure is not fatal 161 */ 162 163 acpi_status = amdgpu_acpi_init(adev); 164 if (acpi_status) 165 dev_dbg(dev->dev, "Error during ACPI methods call\n"); 166 167 if (amdgpu_acpi_smart_shift_update(adev, AMDGPU_SS_DRV_LOAD)) 168 drm_warn(dev, "smart shift update failed\n"); 169 170 out: 171 if (r) 172 amdgpu_driver_unload_kms(dev); 173 174 return r; 175 } 176 177 static enum amd_ip_block_type 178 amdgpu_ip_get_block_type(struct amdgpu_device *adev, uint32_t ip) 179 { 180 enum amd_ip_block_type type; 181 182 switch (ip) { 183 case AMDGPU_HW_IP_GFX: 184 type = AMD_IP_BLOCK_TYPE_GFX; 185 break; 186 case AMDGPU_HW_IP_COMPUTE: 187 type = AMD_IP_BLOCK_TYPE_GFX; 188 break; 189 case AMDGPU_HW_IP_DMA: 190 type = AMD_IP_BLOCK_TYPE_SDMA; 191 break; 192 case AMDGPU_HW_IP_UVD: 193 case AMDGPU_HW_IP_UVD_ENC: 194 type = AMD_IP_BLOCK_TYPE_UVD; 195 break; 196 case AMDGPU_HW_IP_VCE: 197 type = AMD_IP_BLOCK_TYPE_VCE; 198 break; 199 case AMDGPU_HW_IP_VCN_DEC: 200 case AMDGPU_HW_IP_VCN_ENC: 201 type = AMD_IP_BLOCK_TYPE_VCN; 202 break; 203 case AMDGPU_HW_IP_VCN_JPEG: 204 type = (amdgpu_device_ip_get_ip_block(adev, AMD_IP_BLOCK_TYPE_JPEG)) ? 205 AMD_IP_BLOCK_TYPE_JPEG : AMD_IP_BLOCK_TYPE_VCN; 206 break; 207 case AMDGPU_HW_IP_VPE: 208 type = AMD_IP_BLOCK_TYPE_VPE; 209 break; 210 default: 211 type = AMD_IP_BLOCK_TYPE_NUM; 212 break; 213 } 214 215 return type; 216 } 217 218 static int amdgpu_firmware_info(struct drm_amdgpu_info_firmware *fw_info, 219 struct drm_amdgpu_query_fw *query_fw, 220 struct amdgpu_device *adev) 221 { 222 switch (query_fw->fw_type) { 223 case AMDGPU_INFO_FW_VCE: 224 fw_info->ver = adev->vce.fw_version; 225 fw_info->feature = adev->vce.fb_version; 226 break; 227 case AMDGPU_INFO_FW_UVD: 228 fw_info->ver = adev->uvd.fw_version; 229 fw_info->feature = 0; 230 break; 231 case AMDGPU_INFO_FW_VCN: 232 fw_info->ver = adev->vcn.fw_version; 233 fw_info->feature = 0; 234 break; 235 case AMDGPU_INFO_FW_GMC: 236 fw_info->ver = adev->gmc.fw_version; 237 fw_info->feature = 0; 238 break; 239 case AMDGPU_INFO_FW_GFX_ME: 240 fw_info->ver = adev->gfx.me_fw_version; 241 fw_info->feature = adev->gfx.me_feature_version; 242 break; 243 case AMDGPU_INFO_FW_GFX_PFP: 244 fw_info->ver = adev->gfx.pfp_fw_version; 245 fw_info->feature = adev->gfx.pfp_feature_version; 246 break; 247 case AMDGPU_INFO_FW_GFX_CE: 248 fw_info->ver = adev->gfx.ce_fw_version; 249 fw_info->feature = adev->gfx.ce_feature_version; 250 break; 251 case AMDGPU_INFO_FW_GFX_RLC: 252 fw_info->ver = adev->gfx.rlc_fw_version; 253 fw_info->feature = adev->gfx.rlc_feature_version; 254 break; 255 case AMDGPU_INFO_FW_GFX_RLC_RESTORE_LIST_CNTL: 256 fw_info->ver = adev->gfx.rlc_srlc_fw_version; 257 fw_info->feature = adev->gfx.rlc_srlc_feature_version; 258 break; 259 case AMDGPU_INFO_FW_GFX_RLC_RESTORE_LIST_GPM_MEM: 260 fw_info->ver = adev->gfx.rlc_srlg_fw_version; 261 fw_info->feature = adev->gfx.rlc_srlg_feature_version; 262 break; 263 case AMDGPU_INFO_FW_GFX_RLC_RESTORE_LIST_SRM_MEM: 264 fw_info->ver = adev->gfx.rlc_srls_fw_version; 265 fw_info->feature = adev->gfx.rlc_srls_feature_version; 266 break; 267 case AMDGPU_INFO_FW_GFX_RLCP: 268 fw_info->ver = adev->gfx.rlcp_ucode_version; 269 fw_info->feature = adev->gfx.rlcp_ucode_feature_version; 270 break; 271 case AMDGPU_INFO_FW_GFX_RLCV: 272 fw_info->ver = adev->gfx.rlcv_ucode_version; 273 fw_info->feature = adev->gfx.rlcv_ucode_feature_version; 274 break; 275 case AMDGPU_INFO_FW_GFX_MEC: 276 if (query_fw->index == 0) { 277 fw_info->ver = adev->gfx.mec_fw_version; 278 fw_info->feature = adev->gfx.mec_feature_version; 279 } else if (query_fw->index == 1) { 280 fw_info->ver = adev->gfx.mec2_fw_version; 281 fw_info->feature = adev->gfx.mec2_feature_version; 282 } else 283 return -EINVAL; 284 break; 285 case AMDGPU_INFO_FW_SMC: 286 fw_info->ver = adev->pm.fw_version; 287 fw_info->feature = 0; 288 break; 289 case AMDGPU_INFO_FW_MP5: 290 fw_info->ver = adev->pm.mp5_fw_version; 291 fw_info->feature = 0; 292 break; 293 case AMDGPU_INFO_FW_TA: 294 switch (query_fw->index) { 295 case TA_FW_TYPE_PSP_XGMI: 296 fw_info->ver = adev->psp.xgmi_context.context.bin_desc.fw_version; 297 fw_info->feature = adev->psp.xgmi_context.context 298 .bin_desc.feature_version; 299 break; 300 case TA_FW_TYPE_PSP_RAS: 301 fw_info->ver = adev->psp.ras_context.context.bin_desc.fw_version; 302 fw_info->feature = adev->psp.ras_context.context 303 .bin_desc.feature_version; 304 break; 305 case TA_FW_TYPE_PSP_HDCP: 306 fw_info->ver = adev->psp.hdcp_context.context.bin_desc.fw_version; 307 fw_info->feature = adev->psp.hdcp_context.context 308 .bin_desc.feature_version; 309 break; 310 case TA_FW_TYPE_PSP_DTM: 311 fw_info->ver = adev->psp.dtm_context.context.bin_desc.fw_version; 312 fw_info->feature = adev->psp.dtm_context.context 313 .bin_desc.feature_version; 314 break; 315 case TA_FW_TYPE_PSP_RAP: 316 fw_info->ver = adev->psp.rap_context.context.bin_desc.fw_version; 317 fw_info->feature = adev->psp.rap_context.context 318 .bin_desc.feature_version; 319 break; 320 case TA_FW_TYPE_PSP_SECUREDISPLAY: 321 fw_info->ver = adev->psp.securedisplay_context.context.bin_desc.fw_version; 322 fw_info->feature = 323 adev->psp.securedisplay_context.context.bin_desc 324 .feature_version; 325 break; 326 default: 327 return -EINVAL; 328 } 329 break; 330 case AMDGPU_INFO_FW_SDMA: 331 if (query_fw->index >= adev->sdma.num_instances) 332 return -EINVAL; 333 fw_info->ver = adev->sdma.instance[query_fw->index].fw_version; 334 fw_info->feature = adev->sdma.instance[query_fw->index].feature_version; 335 break; 336 case AMDGPU_INFO_FW_SOS: 337 fw_info->ver = adev->psp.sos.fw_version; 338 fw_info->feature = adev->psp.sos.feature_version; 339 break; 340 case AMDGPU_INFO_FW_ASD: 341 fw_info->ver = adev->psp.asd_context.bin_desc.fw_version; 342 fw_info->feature = adev->psp.asd_context.bin_desc.feature_version; 343 break; 344 case AMDGPU_INFO_FW_DMCU: 345 fw_info->ver = adev->dm.dmcu_fw_version; 346 fw_info->feature = 0; 347 break; 348 case AMDGPU_INFO_FW_DMCUB: 349 fw_info->ver = adev->dm.dmcub_fw_version; 350 fw_info->feature = 0; 351 break; 352 case AMDGPU_INFO_FW_TOC: 353 fw_info->ver = adev->psp.toc.fw_version; 354 fw_info->feature = adev->psp.toc.feature_version; 355 break; 356 case AMDGPU_INFO_FW_CAP: 357 fw_info->ver = adev->psp.cap.fw_version; 358 fw_info->feature = adev->psp.cap.feature_version; 359 break; 360 case AMDGPU_INFO_FW_MES_KIQ: 361 fw_info->ver = adev->mes.kiq_version & AMDGPU_MES_VERSION_MASK; 362 fw_info->feature = (adev->mes.kiq_version & AMDGPU_MES_FEAT_VERSION_MASK) 363 >> AMDGPU_MES_FEAT_VERSION_SHIFT; 364 break; 365 case AMDGPU_INFO_FW_MES: 366 fw_info->ver = adev->mes.sched_version & AMDGPU_MES_VERSION_MASK; 367 fw_info->feature = (adev->mes.sched_version & AMDGPU_MES_FEAT_VERSION_MASK) 368 >> AMDGPU_MES_FEAT_VERSION_SHIFT; 369 break; 370 case AMDGPU_INFO_FW_IMU: 371 fw_info->ver = adev->gfx.imu_fw_version; 372 fw_info->feature = 0; 373 break; 374 case AMDGPU_INFO_FW_VPE: 375 fw_info->ver = adev->vpe.fw_version; 376 fw_info->feature = adev->vpe.feature_version; 377 break; 378 default: 379 return -EINVAL; 380 } 381 return 0; 382 } 383 384 static int amdgpu_userq_metadata_info_gfx(struct amdgpu_device *adev, 385 struct drm_amdgpu_info *info, 386 struct drm_amdgpu_info_uq_metadata_gfx *meta) 387 { 388 int ret = -EOPNOTSUPP; 389 390 if (adev->gfx.funcs->get_gfx_shadow_info) { 391 struct amdgpu_gfx_shadow_info shadow = {}; 392 393 adev->gfx.funcs->get_gfx_shadow_info(adev, &shadow, true); 394 meta->shadow_size = shadow.shadow_size; 395 meta->shadow_alignment = shadow.shadow_alignment; 396 meta->csa_size = shadow.csa_size; 397 meta->csa_alignment = shadow.csa_alignment; 398 ret = 0; 399 } 400 401 return ret; 402 } 403 404 static int amdgpu_userq_metadata_info_compute(struct amdgpu_device *adev, 405 struct drm_amdgpu_info *info, 406 struct drm_amdgpu_info_uq_metadata_compute *meta) 407 { 408 int ret = -EOPNOTSUPP; 409 410 if (adev->gfx.funcs->get_gfx_shadow_info) { 411 struct amdgpu_gfx_shadow_info shadow = {}; 412 413 adev->gfx.funcs->get_gfx_shadow_info(adev, &shadow, true); 414 meta->eop_size = shadow.eop_size; 415 meta->eop_alignment = shadow.eop_alignment; 416 ret = 0; 417 } 418 419 return ret; 420 } 421 422 static int amdgpu_userq_metadata_info_sdma(struct amdgpu_device *adev, 423 struct drm_amdgpu_info *info, 424 struct drm_amdgpu_info_uq_metadata_sdma *meta) 425 { 426 int ret = -EOPNOTSUPP; 427 428 if (adev->sdma.get_csa_info) { 429 struct amdgpu_sdma_csa_info csa = {}; 430 431 adev->sdma.get_csa_info(adev, &csa); 432 meta->csa_size = csa.size; 433 meta->csa_alignment = csa.alignment; 434 ret = 0; 435 } 436 437 return ret; 438 } 439 440 static int amdgpu_hw_ip_info(struct amdgpu_device *adev, 441 struct drm_amdgpu_info *info, 442 struct drm_amdgpu_info_hw_ip *result) 443 { 444 uint32_t ib_start_alignment = 0; 445 uint32_t ib_size_alignment = 0; 446 enum amd_ip_block_type type; 447 unsigned int num_rings = 0; 448 uint32_t num_slots = 0; 449 unsigned int i, j; 450 451 if (info->query_hw_ip.ip_instance >= AMDGPU_HW_IP_INSTANCE_MAX_COUNT) 452 return -EINVAL; 453 454 switch (info->query_hw_ip.type) { 455 case AMDGPU_HW_IP_GFX: 456 type = AMD_IP_BLOCK_TYPE_GFX; 457 for (i = 0; i < adev->gfx.num_gfx_rings; i++) 458 if (adev->gfx.gfx_ring[i].sched.ready && 459 !adev->gfx.gfx_ring[i].no_user_submission) 460 ++num_rings; 461 462 if (!adev->gfx.disable_uq) { 463 for (i = 0; i < AMDGPU_MES_MAX_GFX_PIPES; i++) 464 num_slots += hweight32(adev->mes.gfx_hqd_mask[i]); 465 } 466 467 ib_start_alignment = 32; 468 ib_size_alignment = 32; 469 break; 470 case AMDGPU_HW_IP_COMPUTE: 471 type = AMD_IP_BLOCK_TYPE_GFX; 472 for (i = 0; i < adev->gfx.num_compute_rings; i++) 473 if (adev->gfx.compute_ring[i].sched.ready && 474 !adev->gfx.compute_ring[i].no_user_submission) 475 ++num_rings; 476 477 if (!adev->sdma.disable_uq) { 478 for (i = 0; i < AMDGPU_MES_MAX_COMPUTE_PIPES; i++) 479 num_slots += hweight32(adev->mes.compute_hqd_mask[i]); 480 } 481 482 ib_start_alignment = 32; 483 ib_size_alignment = 32; 484 break; 485 case AMDGPU_HW_IP_DMA: 486 type = AMD_IP_BLOCK_TYPE_SDMA; 487 for (i = 0; i < adev->sdma.num_instances; i++) 488 if (adev->sdma.instance[i].ring.sched.ready && 489 !adev->sdma.instance[i].ring.no_user_submission) 490 ++num_rings; 491 492 if (!adev->gfx.disable_uq) { 493 for (i = 0; i < AMDGPU_MES_MAX_SDMA_PIPES; i++) 494 num_slots += hweight32(adev->mes.sdma_hqd_mask[i]); 495 } 496 497 ib_start_alignment = 256; 498 ib_size_alignment = 4; 499 break; 500 case AMDGPU_HW_IP_UVD: 501 type = AMD_IP_BLOCK_TYPE_UVD; 502 for (i = 0; i < adev->uvd.num_uvd_inst; i++) { 503 if (adev->uvd.harvest_config & (1 << i)) 504 continue; 505 506 if (adev->uvd.inst[i].ring.sched.ready && 507 !adev->uvd.inst[i].ring.no_user_submission) 508 ++num_rings; 509 } 510 ib_start_alignment = 256; 511 ib_size_alignment = 64; 512 break; 513 case AMDGPU_HW_IP_VCE: 514 type = AMD_IP_BLOCK_TYPE_VCE; 515 for (i = 0; i < adev->vce.num_rings; i++) 516 if (adev->vce.ring[i].sched.ready && 517 !adev->vce.ring[i].no_user_submission) 518 ++num_rings; 519 ib_start_alignment = 256; 520 ib_size_alignment = 4; 521 break; 522 case AMDGPU_HW_IP_UVD_ENC: 523 type = AMD_IP_BLOCK_TYPE_UVD; 524 for (i = 0; i < adev->uvd.num_uvd_inst; i++) { 525 if (adev->uvd.harvest_config & (1 << i)) 526 continue; 527 528 for (j = 0; j < adev->uvd.num_enc_rings; j++) 529 if (adev->uvd.inst[i].ring_enc[j].sched.ready && 530 !adev->uvd.inst[i].ring_enc[j].no_user_submission) 531 ++num_rings; 532 } 533 ib_start_alignment = 256; 534 ib_size_alignment = 4; 535 break; 536 case AMDGPU_HW_IP_VCN_DEC: 537 type = AMD_IP_BLOCK_TYPE_VCN; 538 for (i = 0; i < adev->vcn.num_vcn_inst; i++) { 539 if (adev->vcn.harvest_config & (1 << i)) 540 continue; 541 542 if (adev->vcn.inst[i].ring_dec.sched.ready && 543 !adev->vcn.inst[i].ring_dec.no_user_submission) 544 ++num_rings; 545 } 546 ib_start_alignment = 256; 547 ib_size_alignment = 64; 548 break; 549 case AMDGPU_HW_IP_VCN_ENC: 550 type = AMD_IP_BLOCK_TYPE_VCN; 551 for (i = 0; i < adev->vcn.num_vcn_inst; i++) { 552 if (adev->vcn.harvest_config & (1 << i)) 553 continue; 554 555 for (j = 0; j < adev->vcn.inst[i].num_enc_rings; j++) 556 if (adev->vcn.inst[i].ring_enc[j].sched.ready && 557 !adev->vcn.inst[i].ring_enc[j].no_user_submission) 558 ++num_rings; 559 } 560 ib_start_alignment = 256; 561 ib_size_alignment = 4; 562 break; 563 case AMDGPU_HW_IP_VCN_JPEG: 564 type = (amdgpu_device_ip_get_ip_block(adev, AMD_IP_BLOCK_TYPE_JPEG)) ? 565 AMD_IP_BLOCK_TYPE_JPEG : AMD_IP_BLOCK_TYPE_VCN; 566 567 for (i = 0; i < adev->jpeg.num_jpeg_inst; i++) { 568 if (adev->jpeg.harvest_config & (1 << i)) 569 continue; 570 571 for (j = 0; j < adev->jpeg.num_jpeg_rings; j++) 572 if (adev->jpeg.inst[i].ring_dec[j].sched.ready && 573 !adev->jpeg.inst[i].ring_dec[j].no_user_submission) 574 ++num_rings; 575 } 576 ib_start_alignment = 256; 577 ib_size_alignment = 64; 578 break; 579 case AMDGPU_HW_IP_VPE: 580 type = AMD_IP_BLOCK_TYPE_VPE; 581 if (adev->vpe.ring.sched.ready && 582 !adev->vpe.ring.no_user_submission) 583 ++num_rings; 584 ib_start_alignment = 256; 585 ib_size_alignment = 4; 586 break; 587 default: 588 return -EINVAL; 589 } 590 591 for (i = 0; i < adev->num_ip_blocks; i++) 592 if (adev->ip_blocks[i].version->type == type && 593 adev->ip_blocks[i].status.valid) 594 break; 595 596 if (i == adev->num_ip_blocks) 597 return 0; 598 599 num_rings = min(amdgpu_ctx_num_entities[info->query_hw_ip.type], 600 num_rings); 601 602 result->hw_ip_version_major = adev->ip_blocks[i].version->major; 603 result->hw_ip_version_minor = adev->ip_blocks[i].version->minor; 604 605 if (adev->asic_type >= CHIP_VEGA10) { 606 switch (type) { 607 case AMD_IP_BLOCK_TYPE_GFX: 608 result->ip_discovery_version = 609 IP_VERSION_MAJ_MIN_REV(amdgpu_ip_version(adev, GC_HWIP, 0)); 610 break; 611 case AMD_IP_BLOCK_TYPE_SDMA: 612 result->ip_discovery_version = 613 IP_VERSION_MAJ_MIN_REV(amdgpu_ip_version(adev, SDMA0_HWIP, 0)); 614 break; 615 case AMD_IP_BLOCK_TYPE_UVD: 616 case AMD_IP_BLOCK_TYPE_VCN: 617 case AMD_IP_BLOCK_TYPE_JPEG: 618 result->ip_discovery_version = 619 IP_VERSION_MAJ_MIN_REV(amdgpu_ip_version(adev, UVD_HWIP, 0)); 620 break; 621 case AMD_IP_BLOCK_TYPE_VCE: 622 result->ip_discovery_version = 623 IP_VERSION_MAJ_MIN_REV(amdgpu_ip_version(adev, VCE_HWIP, 0)); 624 break; 625 case AMD_IP_BLOCK_TYPE_VPE: 626 result->ip_discovery_version = 627 IP_VERSION_MAJ_MIN_REV(amdgpu_ip_version(adev, VPE_HWIP, 0)); 628 break; 629 default: 630 result->ip_discovery_version = 0; 631 break; 632 } 633 } else { 634 result->ip_discovery_version = 0; 635 } 636 result->capabilities_flags = 0; 637 result->available_rings = (1 << num_rings) - 1; 638 result->userq_num_slots = num_slots; 639 result->ib_start_alignment = ib_start_alignment; 640 result->ib_size_alignment = ib_size_alignment; 641 return 0; 642 } 643 644 /* 645 * Userspace get information ioctl 646 */ 647 /** 648 * amdgpu_info_ioctl - answer a device specific request. 649 * 650 * @dev: drm device pointer 651 * @data: request object 652 * @filp: drm filp 653 * 654 * This function is used to pass device specific parameters to the userspace 655 * drivers. Examples include: pci device id, pipeline parms, tiling params, 656 * etc. (all asics). 657 * Returns 0 on success, -EINVAL on failure. 658 */ 659 int amdgpu_info_ioctl(struct drm_device *dev, void *data, struct drm_file *filp) 660 { 661 struct amdgpu_device *adev = drm_to_adev(dev); 662 struct drm_amdgpu_info *info = data; 663 struct amdgpu_mode_info *minfo = &adev->mode_info; 664 void __user *out = (void __user *)(uintptr_t)info->return_pointer; 665 struct amdgpu_fpriv *fpriv; 666 struct amdgpu_ip_block *ip_block; 667 enum amd_ip_block_type type; 668 struct amdgpu_xcp *xcp; 669 u32 count, inst_mask; 670 uint32_t size = info->return_size; 671 struct drm_crtc *crtc; 672 uint32_t ui32 = 0; 673 uint64_t ui64 = 0; 674 int i, found, ret; 675 int ui32_size = sizeof(ui32); 676 677 if (!info->return_size || !info->return_pointer) 678 return -EINVAL; 679 680 switch (info->query) { 681 case AMDGPU_INFO_ACCEL_WORKING: 682 ui32 = adev->accel_working; 683 return copy_to_user(out, &ui32, min(size, 4u)) ? -EFAULT : 0; 684 case AMDGPU_INFO_CRTC_FROM_ID: 685 for (i = 0, found = 0; i < adev->mode_info.num_crtc; i++) { 686 crtc = (struct drm_crtc *)minfo->crtcs[i]; 687 if (crtc && crtc->base.id == info->mode_crtc.id) { 688 struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc); 689 690 ui32 = amdgpu_crtc->crtc_id; 691 found = 1; 692 break; 693 } 694 } 695 if (!found) { 696 DRM_DEBUG_KMS("unknown crtc id %d\n", info->mode_crtc.id); 697 return -EINVAL; 698 } 699 return copy_to_user(out, &ui32, min(size, 4u)) ? -EFAULT : 0; 700 case AMDGPU_INFO_HW_IP_INFO: { 701 struct drm_amdgpu_info_hw_ip ip = {}; 702 703 ret = amdgpu_hw_ip_info(adev, info, &ip); 704 if (ret) 705 return ret; 706 707 ret = copy_to_user(out, &ip, min_t(size_t, size, sizeof(ip))); 708 return ret ? -EFAULT : 0; 709 } 710 case AMDGPU_INFO_HW_IP_COUNT: { 711 fpriv = (struct amdgpu_fpriv *)filp->driver_priv; 712 type = amdgpu_ip_get_block_type(adev, info->query_hw_ip.type); 713 ip_block = amdgpu_device_ip_get_ip_block(adev, type); 714 715 if (!ip_block || !ip_block->status.valid) 716 return -EINVAL; 717 718 if (adev->xcp_mgr && adev->xcp_mgr->num_xcps > 0 && 719 fpriv->xcp_id < adev->xcp_mgr->num_xcps) { 720 xcp = &adev->xcp_mgr->xcp[fpriv->xcp_id]; 721 switch (type) { 722 case AMD_IP_BLOCK_TYPE_GFX: 723 ret = amdgpu_xcp_get_inst_details(xcp, AMDGPU_XCP_GFX, &inst_mask); 724 if (ret) 725 return ret; 726 count = hweight32(inst_mask); 727 break; 728 case AMD_IP_BLOCK_TYPE_SDMA: 729 ret = amdgpu_xcp_get_inst_details(xcp, AMDGPU_XCP_SDMA, &inst_mask); 730 if (ret) 731 return ret; 732 count = hweight32(inst_mask); 733 break; 734 case AMD_IP_BLOCK_TYPE_JPEG: 735 ret = amdgpu_xcp_get_inst_details(xcp, AMDGPU_XCP_VCN, &inst_mask); 736 if (ret) 737 return ret; 738 count = hweight32(inst_mask) * adev->jpeg.num_jpeg_rings; 739 break; 740 case AMD_IP_BLOCK_TYPE_VCN: 741 ret = amdgpu_xcp_get_inst_details(xcp, AMDGPU_XCP_VCN, &inst_mask); 742 if (ret) 743 return ret; 744 count = hweight32(inst_mask); 745 break; 746 default: 747 return -EINVAL; 748 } 749 750 return copy_to_user(out, &count, min(size, 4u)) ? -EFAULT : 0; 751 } 752 753 switch (type) { 754 case AMD_IP_BLOCK_TYPE_GFX: 755 case AMD_IP_BLOCK_TYPE_VCE: 756 count = 1; 757 break; 758 case AMD_IP_BLOCK_TYPE_SDMA: 759 count = adev->sdma.num_instances; 760 break; 761 case AMD_IP_BLOCK_TYPE_JPEG: 762 count = adev->jpeg.num_jpeg_inst * adev->jpeg.num_jpeg_rings; 763 break; 764 case AMD_IP_BLOCK_TYPE_VCN: 765 count = adev->vcn.num_vcn_inst; 766 break; 767 case AMD_IP_BLOCK_TYPE_UVD: 768 count = adev->uvd.num_uvd_inst; 769 break; 770 case AMD_IP_BLOCK_TYPE_VPE: 771 count = adev->vpe.num_instances; 772 break; 773 /* For all other IP block types not listed in the switch statement 774 * the ip status is valid here and the instance count is one. 775 */ 776 default: 777 count = 1; 778 break; 779 } 780 781 return copy_to_user(out, &count, min(size, 4u)) ? -EFAULT : 0; 782 } 783 case AMDGPU_INFO_TIMESTAMP: { 784 PM_RUNTIME_ACQUIRE_IF_ENABLED_AUTOSUSPEND(dev->dev, pm); 785 786 ret = PM_RUNTIME_ACQUIRE_ERR(&pm); 787 if (ret) 788 return ret; 789 790 ui64 = amdgpu_gfx_get_gpu_clock_counter(adev); 791 return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0; 792 } 793 case AMDGPU_INFO_FW_VERSION: { 794 struct drm_amdgpu_info_firmware fw_info; 795 796 /* We only support one instance of each IP block right now. */ 797 if (info->query_fw.ip_instance != 0) 798 return -EINVAL; 799 800 ret = amdgpu_firmware_info(&fw_info, &info->query_fw, adev); 801 if (ret) 802 return ret; 803 804 return copy_to_user(out, &fw_info, 805 min((size_t)size, sizeof(fw_info))) ? -EFAULT : 0; 806 } 807 case AMDGPU_INFO_NUM_BYTES_MOVED: 808 ui64 = atomic64_read(&adev->num_bytes_moved); 809 return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0; 810 case AMDGPU_INFO_NUM_EVICTIONS: 811 ui64 = atomic64_read(&adev->num_evictions); 812 return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0; 813 case AMDGPU_INFO_NUM_VRAM_CPU_PAGE_FAULTS: 814 ui64 = atomic64_read(&adev->num_vram_cpu_page_faults); 815 return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0; 816 case AMDGPU_INFO_VRAM_USAGE: 817 ui64 = ttm_resource_manager_used(&adev->mman.vram_mgr.manager) ? 818 ttm_resource_manager_usage(&adev->mman.vram_mgr.manager) : 0; 819 return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0; 820 case AMDGPU_INFO_VIS_VRAM_USAGE: 821 ui64 = amdgpu_vram_mgr_vis_usage(&adev->mman.vram_mgr); 822 return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0; 823 case AMDGPU_INFO_GTT_USAGE: 824 ui64 = ttm_resource_manager_usage(&adev->mman.gtt_mgr.manager); 825 return copy_to_user(out, &ui64, min(size, 8u)) ? -EFAULT : 0; 826 case AMDGPU_INFO_GDS_CONFIG: { 827 struct drm_amdgpu_info_gds gds_info; 828 829 memset(&gds_info, 0, sizeof(gds_info)); 830 gds_info.compute_partition_size = adev->gds.gds_size; 831 gds_info.gds_total_size = adev->gds.gds_size; 832 gds_info.gws_per_compute_partition = adev->gds.gws_size; 833 gds_info.oa_per_compute_partition = adev->gds.oa_size; 834 return copy_to_user(out, &gds_info, 835 min((size_t)size, sizeof(gds_info))) ? -EFAULT : 0; 836 } 837 case AMDGPU_INFO_VRAM_GTT: { 838 struct drm_amdgpu_info_vram_gtt vram_gtt; 839 840 vram_gtt.vram_size = adev->gmc.real_vram_size - 841 atomic64_read(&adev->vram_pin_size) - 842 AMDGPU_VM_RESERVED_VRAM; 843 vram_gtt.vram_cpu_accessible_size = 844 min(adev->gmc.visible_vram_size - 845 atomic64_read(&adev->visible_pin_size), 846 vram_gtt.vram_size); 847 vram_gtt.gtt_size = ttm_manager_type(&adev->mman.bdev, TTM_PL_TT)->size; 848 vram_gtt.gtt_size -= atomic64_read(&adev->gart_pin_size); 849 return copy_to_user(out, &vram_gtt, 850 min((size_t)size, sizeof(vram_gtt))) ? -EFAULT : 0; 851 } 852 case AMDGPU_INFO_MEMORY: { 853 struct drm_amdgpu_memory_info mem; 854 struct ttm_resource_manager *gtt_man = 855 &adev->mman.gtt_mgr.manager; 856 struct ttm_resource_manager *vram_man = 857 &adev->mman.vram_mgr.manager; 858 859 memset(&mem, 0, sizeof(mem)); 860 mem.vram.total_heap_size = adev->gmc.real_vram_size; 861 mem.vram.usable_heap_size = adev->gmc.real_vram_size - 862 atomic64_read(&adev->vram_pin_size) - 863 AMDGPU_VM_RESERVED_VRAM; 864 mem.vram.heap_usage = ttm_resource_manager_used(&adev->mman.vram_mgr.manager) ? 865 ttm_resource_manager_usage(vram_man) : 0; 866 mem.vram.max_allocation = mem.vram.usable_heap_size * 3 / 4; 867 868 mem.cpu_accessible_vram.total_heap_size = 869 adev->gmc.visible_vram_size; 870 mem.cpu_accessible_vram.usable_heap_size = 871 min(adev->gmc.visible_vram_size - 872 atomic64_read(&adev->visible_pin_size), 873 mem.vram.usable_heap_size); 874 mem.cpu_accessible_vram.heap_usage = 875 amdgpu_vram_mgr_vis_usage(&adev->mman.vram_mgr); 876 mem.cpu_accessible_vram.max_allocation = 877 mem.cpu_accessible_vram.usable_heap_size * 3 / 4; 878 879 mem.gtt.total_heap_size = gtt_man->size; 880 mem.gtt.usable_heap_size = mem.gtt.total_heap_size - 881 atomic64_read(&adev->gart_pin_size); 882 mem.gtt.heap_usage = ttm_resource_manager_usage(gtt_man); 883 mem.gtt.max_allocation = mem.gtt.usable_heap_size * 3 / 4; 884 885 return copy_to_user(out, &mem, 886 min((size_t)size, sizeof(mem))) 887 ? -EFAULT : 0; 888 } 889 case AMDGPU_INFO_READ_MMR_REG: { 890 unsigned int se_num = (info->read_mmr_reg.instance >> 891 AMDGPU_INFO_MMR_SE_INDEX_SHIFT) & 892 AMDGPU_INFO_MMR_SE_INDEX_MASK; 893 unsigned int sh_num = (info->read_mmr_reg.instance >> 894 AMDGPU_INFO_MMR_SH_INDEX_SHIFT) & 895 AMDGPU_INFO_MMR_SH_INDEX_MASK; 896 unsigned int alloc_size; 897 uint32_t *regs; 898 int ret; 899 900 /* set full masks if the userspace set all bits 901 * in the bitfields 902 */ 903 if (se_num == AMDGPU_INFO_MMR_SE_INDEX_MASK) 904 se_num = 0xffffffff; 905 else if (se_num >= AMDGPU_GFX_MAX_SE) 906 return -EINVAL; 907 908 if (sh_num == AMDGPU_INFO_MMR_SH_INDEX_MASK) 909 sh_num = 0xffffffff; 910 else if (sh_num >= AMDGPU_GFX_MAX_SH_PER_SE) 911 return -EINVAL; 912 913 if (info->read_mmr_reg.count > 128) 914 return -EINVAL; 915 916 PM_RUNTIME_ACQUIRE_IF_ENABLED_AUTOSUSPEND(dev->dev, pm); 917 918 ret = PM_RUNTIME_ACQUIRE_ERR(&pm); 919 if (ret) 920 return ret; 921 922 regs = kmalloc_objs(*regs, info->read_mmr_reg.count); 923 if (!regs) 924 return -ENOMEM; 925 926 down_read(&adev->reset_domain->sem); 927 alloc_size = info->read_mmr_reg.count * sizeof(*regs); 928 amdgpu_gfx_off_ctrl(adev, false); 929 ret = 0; 930 for (i = 0; i < info->read_mmr_reg.count; i++) { 931 if (amdgpu_asic_read_register(adev, se_num, sh_num, 932 info->read_mmr_reg.dword_offset + i, 933 ®s[i])) { 934 DRM_DEBUG_KMS("unallowed offset %#x\n", 935 info->read_mmr_reg.dword_offset + i); 936 ret = -EFAULT; 937 break; 938 } 939 } 940 amdgpu_gfx_off_ctrl(adev, true); 941 up_read(&adev->reset_domain->sem); 942 943 if (!ret) { 944 ret = copy_to_user(out, regs, min(size, alloc_size)) 945 ? -EFAULT : 0; 946 } 947 kfree(regs); 948 return ret; 949 } 950 case AMDGPU_INFO_DEV_INFO: { 951 struct drm_amdgpu_info_device *dev_info; 952 uint64_t vm_size; 953 uint32_t pcie_gen_mask, pcie_width_mask; 954 955 /* The clock limits are only available while the SMU is up. */ 956 PM_RUNTIME_ACQUIRE_IF_ENABLED_AUTOSUSPEND(dev->dev, pm); 957 958 ret = PM_RUNTIME_ACQUIRE_ERR(&pm); 959 if (ret) 960 return ret; 961 962 dev_info = kzalloc_obj(*dev_info); 963 if (!dev_info) 964 return -ENOMEM; 965 966 dev_info->device_id = adev->pdev->device; 967 dev_info->chip_rev = adev->rev_id; 968 dev_info->external_rev = adev->external_rev_id; 969 dev_info->pci_rev = adev->pdev->revision; 970 dev_info->family = adev->family; 971 dev_info->num_shader_engines = adev->gfx.config.max_shader_engines; 972 dev_info->num_shader_arrays_per_engine = adev->gfx.config.max_sh_per_se; 973 /* return all clocks in KHz */ 974 dev_info->gpu_counter_freq = amdgpu_asic_get_xclk(adev) * 10; 975 if (adev->pm.dpm_enabled) { 976 dev_info->max_engine_clock = amdgpu_dpm_get_sclk(adev, false) * 10; 977 dev_info->max_memory_clock = amdgpu_dpm_get_mclk(adev, false) * 10; 978 dev_info->min_engine_clock = amdgpu_dpm_get_sclk(adev, true) * 10; 979 dev_info->min_memory_clock = amdgpu_dpm_get_mclk(adev, true) * 10; 980 } else { 981 dev_info->max_engine_clock = 982 dev_info->min_engine_clock = 983 adev->clock.default_sclk * 10; 984 dev_info->max_memory_clock = 985 dev_info->min_memory_clock = 986 adev->clock.default_mclk * 10; 987 } 988 dev_info->enabled_rb_pipes_mask = adev->gfx.config.backend_enable_mask; 989 dev_info->num_rb_pipes = adev->gfx.config.max_backends_per_se * 990 adev->gfx.config.max_shader_engines; 991 dev_info->num_hw_gfx_contexts = adev->gfx.config.max_hw_contexts; 992 dev_info->ids_flags = 0; 993 if (adev->flags & AMD_IS_APU) 994 dev_info->ids_flags |= AMDGPU_IDS_FLAGS_FUSION; 995 if (adev->gfx.mcbp) 996 dev_info->ids_flags |= AMDGPU_IDS_FLAGS_PREEMPTION; 997 if (amdgpu_is_tmz(adev)) 998 dev_info->ids_flags |= AMDGPU_IDS_FLAGS_TMZ; 999 if (adev->gfx.config.ta_cntl2_truncate_coord_mode) 1000 dev_info->ids_flags |= AMDGPU_IDS_FLAGS_CONFORMANT_TRUNC_COORD; 1001 1002 /* Gang submit is not supported under SRIOV currently */ 1003 if (!amdgpu_sriov_vf(adev)) 1004 dev_info->ids_flags |= AMDGPU_IDS_FLAGS_GANG_SUBMIT; 1005 1006 if (amdgpu_passthrough(adev)) 1007 dev_info->ids_flags |= (AMDGPU_IDS_FLAGS_MODE_PT << 1008 AMDGPU_IDS_FLAGS_MODE_SHIFT) & 1009 AMDGPU_IDS_FLAGS_MODE_MASK; 1010 else if (amdgpu_sriov_vf(adev)) 1011 dev_info->ids_flags |= (AMDGPU_IDS_FLAGS_MODE_VF << 1012 AMDGPU_IDS_FLAGS_MODE_SHIFT) & 1013 AMDGPU_IDS_FLAGS_MODE_MASK; 1014 1015 vm_size = adev->vm_manager.max_pfn * AMDGPU_GPU_PAGE_SIZE; 1016 vm_size -= AMDGPU_VA_RESERVED_TOP; 1017 1018 /* Older VCE FW versions are buggy and can handle only 40bits */ 1019 if (adev->vce.fw_version && 1020 adev->vce.fw_version < AMDGPU_VCE_FW_53_45) 1021 vm_size = min(vm_size, 1ULL << 40); 1022 1023 dev_info->virtual_address_offset = AMDGPU_VA_RESERVED_BOTTOM; 1024 dev_info->virtual_address_max = 1025 min(vm_size, AMDGPU_GMC_HOLE_START); 1026 1027 if (vm_size > AMDGPU_GMC_HOLE_START) { 1028 dev_info->high_va_offset = AMDGPU_GMC_HOLE_END; 1029 dev_info->high_va_max = AMDGPU_GMC_HOLE_END | vm_size; 1030 } 1031 dev_info->virtual_address_alignment = max_t(u32, PAGE_SIZE, AMDGPU_GPU_PAGE_SIZE); 1032 dev_info->pte_fragment_size = (1 << adev->vm_manager.fragment_size) * AMDGPU_GPU_PAGE_SIZE; 1033 dev_info->gart_page_size = max_t(u32, PAGE_SIZE, AMDGPU_GPU_PAGE_SIZE); 1034 dev_info->cu_active_number = adev->gfx.cu_info.number; 1035 dev_info->cu_ao_mask = adev->gfx.cu_info.ao_cu_mask; 1036 dev_info->ce_ram_size = adev->gfx.ce_ram_size; 1037 memcpy(&dev_info->cu_ao_bitmap[0], &adev->gfx.cu_info.ao_cu_bitmap[0], 1038 sizeof(adev->gfx.cu_info.ao_cu_bitmap)); 1039 memcpy(&dev_info->cu_bitmap[0], &adev->gfx.cu_info.bitmap[0], 1040 sizeof(dev_info->cu_bitmap)); 1041 dev_info->vram_type = adev->gmc.vram_type; 1042 dev_info->vram_bit_width = adev->gmc.vram_width; 1043 dev_info->vce_harvest_config = adev->vce.harvest_config; 1044 dev_info->gc_double_offchip_lds_buf = 1045 adev->gfx.config.double_offchip_lds_buf; 1046 dev_info->wave_front_size = adev->gfx.cu_info.wave_front_size; 1047 dev_info->num_shader_visible_vgprs = adev->gfx.config.max_gprs; 1048 dev_info->num_cu_per_sh = adev->gfx.config.max_cu_per_sh; 1049 dev_info->num_tcc_blocks = adev->gfx.config.max_texture_channel_caches; 1050 dev_info->gs_vgt_table_depth = adev->gfx.config.gs_vgt_table_depth; 1051 dev_info->gs_prim_buffer_depth = adev->gfx.config.gs_prim_buffer_depth; 1052 dev_info->max_gs_waves_per_vgt = adev->gfx.config.max_gs_threads; 1053 1054 if (adev->family >= AMDGPU_FAMILY_NV) 1055 dev_info->pa_sc_tile_steering_override = 1056 adev->gfx.config.pa_sc_tile_steering_override; 1057 1058 dev_info->tcc_disabled_mask = adev->gfx.config.tcc_disabled_mask; 1059 1060 /* Combine the chip gen mask with the platform (CPU/mobo) mask. */ 1061 pcie_gen_mask = adev->pm.pcie_gen_mask & 1062 (adev->pm.pcie_gen_mask >> CAIL_PCIE_LINK_SPEED_SUPPORT_SHIFT); 1063 pcie_width_mask = adev->pm.pcie_mlw_mask & 1064 (adev->pm.pcie_mlw_mask >> CAIL_PCIE_LINK_WIDTH_SUPPORT_SHIFT); 1065 dev_info->pcie_gen = fls(pcie_gen_mask); 1066 dev_info->pcie_num_lanes = 1067 pcie_width_mask & CAIL_ASIC_PCIE_LINK_WIDTH_SUPPORT_X32 ? 32 : 1068 pcie_width_mask & CAIL_ASIC_PCIE_LINK_WIDTH_SUPPORT_X16 ? 16 : 1069 pcie_width_mask & CAIL_ASIC_PCIE_LINK_WIDTH_SUPPORT_X12 ? 12 : 1070 pcie_width_mask & CAIL_ASIC_PCIE_LINK_WIDTH_SUPPORT_X8 ? 8 : 1071 pcie_width_mask & CAIL_ASIC_PCIE_LINK_WIDTH_SUPPORT_X4 ? 4 : 1072 pcie_width_mask & CAIL_ASIC_PCIE_LINK_WIDTH_SUPPORT_X2 ? 2 : 1; 1073 1074 dev_info->tcp_cache_size = adev->gfx.config.gc_tcp_l1_size; 1075 dev_info->num_sqc_per_wgp = adev->gfx.config.gc_num_sqc_per_wgp; 1076 dev_info->sqc_data_cache_size = adev->gfx.config.gc_l1_data_cache_size_per_sqc; 1077 dev_info->sqc_inst_cache_size = adev->gfx.config.gc_l1_instruction_cache_size_per_sqc; 1078 dev_info->gl1c_cache_size = adev->gfx.config.gc_gl1c_size_per_instance * 1079 adev->gfx.config.gc_gl1c_per_sa; 1080 dev_info->gl2c_cache_size = adev->gfx.config.gc_gl2c_per_gpu; 1081 dev_info->mall_size = adev->gmc.mall_size; 1082 1083 1084 if (adev->gfx.funcs->get_gfx_shadow_info) { 1085 struct amdgpu_gfx_shadow_info shadow_info; 1086 1087 ret = amdgpu_gfx_get_gfx_shadow_info(adev, &shadow_info); 1088 if (!ret) { 1089 dev_info->shadow_size = shadow_info.shadow_size; 1090 dev_info->shadow_alignment = shadow_info.shadow_alignment; 1091 dev_info->csa_size = shadow_info.csa_size; 1092 dev_info->csa_alignment = shadow_info.csa_alignment; 1093 } 1094 } 1095 1096 dev_info->userq_ip_mask = amdgpu_userq_get_supported_ip_mask(adev); 1097 1098 ret = copy_to_user(out, dev_info, 1099 min((size_t)size, sizeof(*dev_info))) ? -EFAULT : 0; 1100 kfree(dev_info); 1101 return ret; 1102 } 1103 case AMDGPU_INFO_VCE_CLOCK_TABLE: { 1104 unsigned int i; 1105 struct drm_amdgpu_info_vce_clock_table vce_clk_table = {}; 1106 struct amd_vce_state *vce_state; 1107 1108 for (i = 0; i < AMDGPU_VCE_CLOCK_TABLE_ENTRIES; i++) { 1109 vce_state = amdgpu_dpm_get_vce_clock_state(adev, i); 1110 if (vce_state) { 1111 vce_clk_table.entries[i].sclk = vce_state->sclk; 1112 vce_clk_table.entries[i].mclk = vce_state->mclk; 1113 vce_clk_table.entries[i].eclk = vce_state->evclk; 1114 vce_clk_table.num_valid_entries++; 1115 } 1116 } 1117 1118 return copy_to_user(out, &vce_clk_table, 1119 min((size_t)size, sizeof(vce_clk_table))) ? -EFAULT : 0; 1120 } 1121 case AMDGPU_INFO_VBIOS: { 1122 uint32_t bios_size = adev->bios_size; 1123 1124 switch (info->vbios_info.type) { 1125 case AMDGPU_INFO_VBIOS_SIZE: 1126 return copy_to_user(out, &bios_size, 1127 min((size_t)size, sizeof(bios_size))) 1128 ? -EFAULT : 0; 1129 case AMDGPU_INFO_VBIOS_IMAGE: { 1130 uint8_t *bios; 1131 uint32_t bios_offset = info->vbios_info.offset; 1132 1133 if (bios_offset >= bios_size) 1134 return -EINVAL; 1135 1136 bios = adev->bios + bios_offset; 1137 return copy_to_user(out, bios, 1138 min((size_t)size, (size_t)(bios_size - bios_offset))) 1139 ? -EFAULT : 0; 1140 } 1141 case AMDGPU_INFO_VBIOS_INFO: { 1142 struct drm_amdgpu_info_vbios vbios_info = {}; 1143 struct atom_context *atom_context; 1144 1145 atom_context = adev->mode_info.atom_context; 1146 if (atom_context) { 1147 memcpy(vbios_info.name, atom_context->name, 1148 sizeof(atom_context->name)); 1149 memcpy(vbios_info.vbios_pn, atom_context->vbios_pn, 1150 sizeof(atom_context->vbios_pn)); 1151 vbios_info.version = atom_context->version; 1152 memcpy(vbios_info.vbios_ver_str, atom_context->vbios_ver_str, 1153 sizeof(atom_context->vbios_ver_str)); 1154 memcpy(vbios_info.date, atom_context->date, 1155 sizeof(atom_context->date)); 1156 } 1157 1158 return copy_to_user(out, &vbios_info, 1159 min((size_t)size, sizeof(vbios_info))) ? -EFAULT : 0; 1160 } 1161 default: 1162 DRM_DEBUG_KMS("Invalid request %d\n", 1163 info->vbios_info.type); 1164 return -EINVAL; 1165 } 1166 } 1167 case AMDGPU_INFO_NUM_HANDLES: { 1168 struct drm_amdgpu_info_num_handles handle; 1169 1170 switch (info->query_hw_ip.type) { 1171 case AMDGPU_HW_IP_UVD: 1172 /* Starting Polaris, we support unlimited UVD handles */ 1173 if (adev->asic_type < CHIP_POLARIS10) { 1174 handle.uvd_max_handles = adev->uvd.max_handles; 1175 handle.uvd_used_handles = amdgpu_uvd_used_handles(adev); 1176 1177 return copy_to_user(out, &handle, 1178 min((size_t)size, sizeof(handle))) ? -EFAULT : 0; 1179 } else { 1180 return -ENODATA; 1181 } 1182 1183 break; 1184 default: 1185 return -EINVAL; 1186 } 1187 } 1188 case AMDGPU_INFO_SENSOR: { 1189 PM_RUNTIME_ACQUIRE_IF_ENABLED_AUTOSUSPEND(dev->dev, pm); 1190 1191 ret = PM_RUNTIME_ACQUIRE_ERR(&pm); 1192 if (ret) 1193 return ret; 1194 1195 if (!adev->pm.dpm_enabled) 1196 return -ENOENT; 1197 1198 switch (info->sensor_info.type) { 1199 case AMDGPU_INFO_SENSOR_GFX_SCLK: 1200 /* get sclk in Mhz */ 1201 if (amdgpu_dpm_read_sensor(adev, 1202 AMDGPU_PP_SENSOR_GFX_SCLK, 1203 (void *)&ui32, &ui32_size)) { 1204 return -EINVAL; 1205 } 1206 ui32 /= 100; 1207 break; 1208 case AMDGPU_INFO_SENSOR_GFX_MCLK: 1209 /* get mclk in Mhz */ 1210 if (amdgpu_dpm_read_sensor(adev, 1211 AMDGPU_PP_SENSOR_GFX_MCLK, 1212 (void *)&ui32, &ui32_size)) { 1213 return -EINVAL; 1214 } 1215 ui32 /= 100; 1216 break; 1217 case AMDGPU_INFO_SENSOR_GPU_TEMP: 1218 /* get temperature in millidegrees C */ 1219 if (amdgpu_dpm_read_sensor(adev, 1220 AMDGPU_PP_SENSOR_GPU_TEMP, 1221 (void *)&ui32, &ui32_size)) { 1222 return -EINVAL; 1223 } 1224 break; 1225 case AMDGPU_INFO_SENSOR_GPU_LOAD: 1226 /* get GPU load */ 1227 if (amdgpu_dpm_read_sensor(adev, 1228 AMDGPU_PP_SENSOR_GPU_LOAD, 1229 (void *)&ui32, &ui32_size)) { 1230 return -EINVAL; 1231 } 1232 break; 1233 case AMDGPU_INFO_SENSOR_GPU_AVG_POWER: 1234 /* get average GPU power */ 1235 if (amdgpu_dpm_read_sensor(adev, 1236 AMDGPU_PP_SENSOR_GPU_AVG_POWER, 1237 (void *)&ui32, &ui32_size)) { 1238 /* fall back to input power for backwards compat */ 1239 if (amdgpu_dpm_read_sensor(adev, 1240 AMDGPU_PP_SENSOR_GPU_INPUT_POWER, 1241 (void *)&ui32, &ui32_size)) { 1242 return -EINVAL; 1243 } 1244 } 1245 ui32 /= MILLIWATT_PER_WATT; 1246 break; 1247 case AMDGPU_INFO_SENSOR_GPU_INPUT_POWER: 1248 /* get input GPU power */ 1249 if (amdgpu_dpm_read_sensor(adev, 1250 AMDGPU_PP_SENSOR_GPU_INPUT_POWER, 1251 (void *)&ui32, &ui32_size)) { 1252 return -EINVAL; 1253 } 1254 ui32 /= MILLIWATT_PER_WATT; 1255 break; 1256 case AMDGPU_INFO_SENSOR_VDDNB: 1257 /* get VDDNB in millivolts */ 1258 if (amdgpu_dpm_read_sensor(adev, 1259 AMDGPU_PP_SENSOR_VDDNB, 1260 (void *)&ui32, &ui32_size)) { 1261 return -EINVAL; 1262 } 1263 break; 1264 case AMDGPU_INFO_SENSOR_VDDGFX: 1265 /* get VDDGFX in millivolts */ 1266 if (amdgpu_dpm_read_sensor(adev, 1267 AMDGPU_PP_SENSOR_VDDGFX, 1268 (void *)&ui32, &ui32_size)) { 1269 return -EINVAL; 1270 } 1271 break; 1272 case AMDGPU_INFO_SENSOR_STABLE_PSTATE_GFX_SCLK: 1273 /* get stable pstate sclk in Mhz */ 1274 if (amdgpu_dpm_read_sensor(adev, 1275 AMDGPU_PP_SENSOR_STABLE_PSTATE_SCLK, 1276 (void *)&ui32, &ui32_size)) { 1277 return -EINVAL; 1278 } 1279 ui32 /= 100; 1280 break; 1281 case AMDGPU_INFO_SENSOR_STABLE_PSTATE_GFX_MCLK: 1282 /* get stable pstate mclk in Mhz */ 1283 if (amdgpu_dpm_read_sensor(adev, 1284 AMDGPU_PP_SENSOR_STABLE_PSTATE_MCLK, 1285 (void *)&ui32, &ui32_size)) { 1286 return -EINVAL; 1287 } 1288 ui32 /= 100; 1289 break; 1290 case AMDGPU_INFO_SENSOR_PEAK_PSTATE_GFX_SCLK: 1291 /* get peak pstate sclk in Mhz */ 1292 if (amdgpu_dpm_read_sensor(adev, 1293 AMDGPU_PP_SENSOR_PEAK_PSTATE_SCLK, 1294 (void *)&ui32, &ui32_size)) { 1295 return -EINVAL; 1296 } 1297 ui32 /= 100; 1298 break; 1299 case AMDGPU_INFO_SENSOR_PEAK_PSTATE_GFX_MCLK: 1300 /* get peak pstate mclk in Mhz */ 1301 if (amdgpu_dpm_read_sensor(adev, 1302 AMDGPU_PP_SENSOR_PEAK_PSTATE_MCLK, 1303 (void *)&ui32, &ui32_size)) { 1304 return -EINVAL; 1305 } 1306 ui32 /= 100; 1307 break; 1308 default: 1309 DRM_DEBUG_KMS("Invalid request %d\n", 1310 info->sensor_info.type); 1311 return -EINVAL; 1312 } 1313 return copy_to_user(out, &ui32, min(size, 4u)) ? -EFAULT : 0; 1314 } 1315 case AMDGPU_INFO_VRAM_LOST_COUNTER: 1316 ui32 = atomic_read(&adev->vram_lost_counter); 1317 return copy_to_user(out, &ui32, min(size, 4u)) ? -EFAULT : 0; 1318 case AMDGPU_INFO_RAS_ENABLED_FEATURES: { 1319 struct amdgpu_ras *ras = amdgpu_ras_get_context(adev); 1320 uint64_t ras_mask; 1321 1322 if (!ras) 1323 return -EINVAL; 1324 1325 if (amdgpu_uniras_enabled(adev)) 1326 ras_mask = amdgpu_uniras_get_ras_caps(adev); 1327 else 1328 ras_mask = (uint64_t)adev->ras_enabled << 32 | ras->features; 1329 1330 return copy_to_user(out, &ras_mask, 1331 min_t(u64, size, sizeof(ras_mask))) ? 1332 -EFAULT : 0; 1333 } 1334 case AMDGPU_INFO_VIDEO_CAPS: { 1335 const struct amdgpu_video_codecs *codecs; 1336 struct drm_amdgpu_info_video_caps *caps; 1337 int r; 1338 1339 if (!adev->asic_funcs->query_video_codecs) 1340 return -EINVAL; 1341 1342 switch (info->video_cap.type) { 1343 case AMDGPU_INFO_VIDEO_CAPS_DECODE: 1344 r = amdgpu_asic_query_video_codecs(adev, false, &codecs); 1345 if (r) 1346 return -EINVAL; 1347 break; 1348 case AMDGPU_INFO_VIDEO_CAPS_ENCODE: 1349 r = amdgpu_asic_query_video_codecs(adev, true, &codecs); 1350 if (r) 1351 return -EINVAL; 1352 break; 1353 default: 1354 DRM_DEBUG_KMS("Invalid request %d\n", 1355 info->video_cap.type); 1356 return -EINVAL; 1357 } 1358 1359 caps = kzalloc_obj(*caps); 1360 if (!caps) 1361 return -ENOMEM; 1362 1363 for (i = 0; i < codecs->codec_count; i++) { 1364 int idx = codecs->codec_array[i].codec_type; 1365 1366 switch (idx) { 1367 case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_MPEG2: 1368 case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_MPEG4: 1369 case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_VC1: 1370 case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_MPEG4_AVC: 1371 case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_HEVC: 1372 case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_JPEG: 1373 case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_VP9: 1374 case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_AV1: 1375 caps->codec_info[idx].valid = 1; 1376 caps->codec_info[idx].max_width = 1377 codecs->codec_array[i].max_width; 1378 caps->codec_info[idx].max_height = 1379 codecs->codec_array[i].max_height; 1380 caps->codec_info[idx].max_pixels_per_frame = 1381 codecs->codec_array[i].max_pixels_per_frame; 1382 caps->codec_info[idx].max_level = 1383 codecs->codec_array[i].max_level; 1384 break; 1385 default: 1386 break; 1387 } 1388 } 1389 r = copy_to_user(out, caps, 1390 min((size_t)size, sizeof(*caps))) ? -EFAULT : 0; 1391 kfree(caps); 1392 return r; 1393 } 1394 case AMDGPU_INFO_MAX_IBS: { 1395 uint32_t max_ibs[AMDGPU_HW_IP_NUM]; 1396 1397 for (i = 0; i < AMDGPU_HW_IP_NUM; ++i) 1398 max_ibs[i] = amdgpu_ring_max_ibs(i); 1399 1400 return copy_to_user(out, max_ibs, 1401 min((size_t)size, sizeof(max_ibs))) ? -EFAULT : 0; 1402 } 1403 case AMDGPU_INFO_GPUVM_FAULT: { 1404 struct amdgpu_fpriv *fpriv = filp->driver_priv; 1405 struct amdgpu_vm *vm = &fpriv->vm; 1406 struct drm_amdgpu_info_gpuvm_fault gpuvm_fault; 1407 unsigned long flags; 1408 1409 if (!vm) 1410 return -EINVAL; 1411 1412 memset(&gpuvm_fault, 0, sizeof(gpuvm_fault)); 1413 1414 amdgpu_pasid_lock(&flags); 1415 gpuvm_fault.addr = vm->fault_info.addr; 1416 gpuvm_fault.status = vm->fault_info.status; 1417 gpuvm_fault.vmhub = vm->fault_info.vmhub; 1418 amdgpu_pasid_unlock(flags); 1419 1420 return copy_to_user(out, &gpuvm_fault, 1421 min((size_t)size, sizeof(gpuvm_fault))) ? -EFAULT : 0; 1422 } 1423 case AMDGPU_INFO_UQ_FW_AREAS: { 1424 struct drm_amdgpu_info_uq_metadata meta_info = {}; 1425 1426 switch (info->query_hw_ip.type) { 1427 case AMDGPU_HW_IP_GFX: 1428 ret = amdgpu_userq_metadata_info_gfx(adev, info, &meta_info.gfx); 1429 if (ret) 1430 return ret; 1431 1432 ret = copy_to_user(out, &meta_info, 1433 min((size_t)size, sizeof(meta_info))) ? -EFAULT : 0; 1434 return 0; 1435 case AMDGPU_HW_IP_COMPUTE: 1436 ret = amdgpu_userq_metadata_info_compute(adev, info, &meta_info.compute); 1437 if (ret) 1438 return ret; 1439 1440 ret = copy_to_user(out, &meta_info, 1441 min((size_t)size, sizeof(meta_info))) ? -EFAULT : 0; 1442 return 0; 1443 case AMDGPU_HW_IP_DMA: 1444 ret = amdgpu_userq_metadata_info_sdma(adev, info, &meta_info.sdma); 1445 if (ret) 1446 return ret; 1447 1448 ret = copy_to_user(out, &meta_info, 1449 min((size_t)size, sizeof(meta_info))) ? -EFAULT : 0; 1450 return 0; 1451 default: 1452 return -EINVAL; 1453 } 1454 } 1455 default: 1456 DRM_DEBUG_KMS("Invalid request %d\n", info->query); 1457 return -EINVAL; 1458 } 1459 return 0; 1460 } 1461 1462 /** 1463 * amdgpu_proc_options_ioctl - set per-fd user options 1464 * 1465 * @dev: drm dev pointer 1466 * @data: pointer to struct drm_amdgpu_proc_options 1467 * @filp: drm file 1468 * 1469 * Sets options stored on the per-file amdgpu_fpriv. Currently the only 1470 * supported option is %AMDGPU_PROC_OPTIONS_OP_KFD_SIGBUS_DELAY which 1471 * controls how KFD delivers SIGBUS for poison/RAS events to the calling 1472 * process (immediate, suppressed, or delayed by N milliseconds). 1473 */ 1474 int amdgpu_proc_options_ioctl(struct drm_device *dev, void *data, 1475 struct drm_file *filp) 1476 { 1477 struct drm_amdgpu_proc_options *args = data; 1478 1479 switch (args->op) { 1480 case AMDGPU_PROC_OPTIONS_OP_KFD_SIGBUS_DELAY: 1481 return amdgpu_amdkfd_set_sigbus_delay(current, 1482 args->kfd_sigbus_delay.value); 1483 default: 1484 DRM_DEBUG_KMS("Invalid user option op %u\n", args->op); 1485 return -EINVAL; 1486 } 1487 } 1488 1489 /** 1490 * amdgpu_driver_open_kms - drm callback for open 1491 * 1492 * @dev: drm dev pointer 1493 * @file_priv: drm file 1494 * 1495 * On device open, init vm on cayman+ (all asics). 1496 * Returns 0 on success, error on failure. 1497 */ 1498 int amdgpu_driver_open_kms(struct drm_device *dev, struct drm_file *file_priv) 1499 { 1500 struct amdgpu_device *adev = drm_to_adev(dev); 1501 struct amdgpu_fpriv *fpriv; 1502 struct drm_exec exec; 1503 int r, pasid = 0; 1504 1505 /* Ensure IB tests are run on ring */ 1506 flush_delayed_work(&adev->delayed_init_work); 1507 1508 1509 if (amdgpu_ras_intr_triggered()) { 1510 DRM_ERROR("RAS Intr triggered, device disabled!!"); 1511 return -EHWPOISON; 1512 } 1513 1514 file_priv->driver_priv = NULL; 1515 1516 r = pm_runtime_get_sync(dev->dev); 1517 if (r < 0) 1518 goto pm_put; 1519 1520 fpriv = kzalloc_obj(*fpriv); 1521 if (unlikely(!fpriv)) { 1522 r = -ENOMEM; 1523 goto out_suspend; 1524 } 1525 1526 r = amdgpu_xcp_open_device(adev, fpriv, file_priv); 1527 if (r) 1528 goto error_pasid; 1529 1530 amdgpu_debugfs_vm_init(file_priv); 1531 1532 r = amdgpu_vm_init(adev, &fpriv->vm, fpriv->xcp_id); 1533 if (r) 1534 goto error_pasid; 1535 1536 pasid = amdgpu_pasid_alloc(16, fpriv); 1537 if (pasid < 0) { 1538 dev_warn(adev->dev, "No more PASIDs available!"); 1539 pasid = 0; 1540 } 1541 fpriv->vm.pasid = pasid; 1542 1543 drm_exec_init(&exec, DRM_EXEC_IGNORE_DUPLICATES, 0); 1544 drm_exec_until_all_locked(&exec) { 1545 r = amdgpu_vm_lock_pd(&fpriv->vm, &exec, 0); 1546 drm_exec_retry_on_contention(&exec); 1547 if (unlikely(r)) 1548 goto error_vm; 1549 } 1550 1551 fpriv->prt_va = amdgpu_vm_bo_add(adev, &fpriv->vm, NULL); 1552 drm_exec_fini(&exec); 1553 if (!fpriv->prt_va) { 1554 r = -ENOMEM; 1555 goto error_vm; 1556 } 1557 1558 if (adev->gfx.mcbp) { 1559 uint64_t csa_addr = amdgpu_csa_vaddr(adev) & AMDGPU_GMC_HOLE_MASK; 1560 1561 r = amdgpu_map_static_csa(adev, &fpriv->vm, adev->virt.csa_obj, 1562 &fpriv->csa_va, csa_addr, AMDGPU_CSA_SIZE); 1563 if (r) 1564 goto error_vm; 1565 } 1566 1567 r = amdgpu_seq64_map(adev, &fpriv->vm, &fpriv->seq64_va); 1568 if (r) 1569 goto error_vm; 1570 1571 xa_init_flags(&fpriv->bo_list_handles, XA_FLAGS_ALLOC1); 1572 1573 r = amdgpu_userq_mgr_init(&fpriv->userq_mgr, file_priv, adev); 1574 if (r) 1575 drm_warn(adev_to_drm(adev), 1576 "Failed to init usermode queue manager (%d), use legacy workload submission only\n", 1577 r); 1578 1579 amdgpu_evf_mgr_init(&fpriv->evf_mgr); 1580 amdgpu_ctx_mgr_init(&fpriv->ctx_mgr, adev); 1581 1582 file_priv->driver_priv = fpriv; 1583 goto out_suspend; 1584 1585 error_vm: 1586 if (pasid) { 1587 amdgpu_pasid_free(pasid); 1588 pasid = 0; 1589 } 1590 1591 amdgpu_vm_fini(adev, &fpriv->vm); 1592 1593 error_pasid: 1594 kfree(fpriv); 1595 1596 out_suspend: 1597 pm_put: 1598 pm_runtime_put_autosuspend(dev->dev); 1599 1600 return r; 1601 } 1602 1603 /** 1604 * amdgpu_driver_postclose_kms - drm callback for post close 1605 * 1606 * @dev: drm dev pointer 1607 * @file_priv: drm file 1608 * 1609 * On device post close, tear down vm on cayman+ (all asics). 1610 */ 1611 void amdgpu_driver_postclose_kms(struct drm_device *dev, 1612 struct drm_file *file_priv) 1613 { 1614 struct amdgpu_device *adev = drm_to_adev(dev); 1615 struct amdgpu_fpriv *fpriv = file_priv->driver_priv; 1616 struct amdgpu_bo_list *list; 1617 struct amdgpu_bo *pd; 1618 unsigned long handle; 1619 u32 pasid; 1620 1621 if (!fpriv) 1622 return; 1623 1624 pm_runtime_get_sync(dev->dev); 1625 1626 if (amdgpu_device_ip_get_ip_block(adev, AMD_IP_BLOCK_TYPE_UVD) != NULL) 1627 amdgpu_uvd_free_handles(adev, file_priv); 1628 if (amdgpu_device_ip_get_ip_block(adev, AMD_IP_BLOCK_TYPE_VCE) != NULL) 1629 amdgpu_vce_free_handles(adev, file_priv); 1630 1631 if (fpriv->csa_va) { 1632 uint64_t csa_addr = amdgpu_csa_vaddr(adev) & AMDGPU_GMC_HOLE_MASK; 1633 1634 WARN_ON(amdgpu_unmap_static_csa(adev, &fpriv->vm, adev->virt.csa_obj, 1635 fpriv->csa_va, csa_addr)); 1636 fpriv->csa_va = NULL; 1637 } 1638 1639 amdgpu_seq64_unmap(adev, fpriv); 1640 1641 pasid = fpriv->vm.pasid; 1642 pd = amdgpu_bo_ref(fpriv->vm.root.bo); 1643 if (!WARN_ON(amdgpu_bo_reserve(pd, true))) { 1644 amdgpu_vm_bo_del(adev, fpriv->prt_va); 1645 amdgpu_bo_unreserve(pd); 1646 } 1647 1648 amdgpu_ctx_mgr_fini(&fpriv->ctx_mgr); 1649 1650 if (pasid) 1651 amdgpu_pasid_free_delayed(pd->tbo.base.resv, pasid); 1652 1653 amdgpu_vm_fini(adev, &fpriv->vm); 1654 amdgpu_bo_unref(&pd); 1655 1656 xa_for_each(&fpriv->bo_list_handles, handle, list) 1657 amdgpu_bo_list_put(list); 1658 xa_destroy(&fpriv->bo_list_handles); 1659 1660 kfree(fpriv); 1661 file_priv->driver_priv = NULL; 1662 1663 pm_runtime_put_autosuspend(dev->dev); 1664 } 1665 1666 1667 void amdgpu_driver_release_kms(struct drm_device *dev) 1668 { 1669 struct amdgpu_device *adev = drm_to_adev(dev); 1670 1671 amdgpu_device_fini_sw(adev); 1672 pci_set_drvdata(adev->pdev, NULL); 1673 } 1674 1675 /* 1676 * VBlank related functions. 1677 */ 1678 /** 1679 * amdgpu_get_vblank_counter_kms - get frame count 1680 * 1681 * @crtc: crtc to get the frame count from 1682 * 1683 * Gets the frame count on the requested crtc (all asics). 1684 * Returns frame count on success, -EINVAL on failure. 1685 */ 1686 u32 amdgpu_get_vblank_counter_kms(struct drm_crtc *crtc) 1687 { 1688 struct drm_device *dev = crtc->dev; 1689 unsigned int pipe = crtc->index; 1690 struct amdgpu_device *adev = drm_to_adev(dev); 1691 int vpos, hpos, stat; 1692 u32 count; 1693 1694 if (pipe >= adev->mode_info.num_crtc) { 1695 DRM_ERROR("Invalid crtc %u\n", pipe); 1696 return -EINVAL; 1697 } 1698 if (!down_read_trylock(&adev->reset_domain->sem)) 1699 return drm_crtc_vblank_count(crtc); 1700 1701 1702 /* The hw increments its frame counter at start of vsync, not at start 1703 * of vblank, as is required by DRM core vblank counter handling. 1704 * Cook the hw count here to make it appear to the caller as if it 1705 * incremented at start of vblank. We measure distance to start of 1706 * vblank in vpos. vpos therefore will be >= 0 between start of vblank 1707 * and start of vsync, so vpos >= 0 means to bump the hw frame counter 1708 * result by 1 to give the proper appearance to caller. 1709 */ 1710 if (adev->mode_info.crtcs[pipe]) { 1711 /* Repeat readout if needed to provide stable result if 1712 * we cross start of vsync during the queries. 1713 */ 1714 do { 1715 count = amdgpu_display_vblank_get_counter(adev, pipe); 1716 /* Ask amdgpu_display_get_crtc_scanoutpos to return 1717 * vpos as distance to start of vblank, instead of 1718 * regular vertical scanout pos. 1719 */ 1720 stat = amdgpu_display_get_crtc_scanoutpos( 1721 dev, pipe, GET_DISTANCE_TO_VBLANKSTART, 1722 &vpos, &hpos, NULL, NULL, 1723 &adev->mode_info.crtcs[pipe]->base.hwmode); 1724 } while (count != amdgpu_display_vblank_get_counter(adev, pipe)); 1725 1726 if (((stat & (DRM_SCANOUTPOS_VALID | DRM_SCANOUTPOS_ACCURATE)) != 1727 (DRM_SCANOUTPOS_VALID | DRM_SCANOUTPOS_ACCURATE))) { 1728 DRM_DEBUG_VBL("Query failed! stat %d\n", stat); 1729 } else { 1730 DRM_DEBUG_VBL("crtc %d: dist from vblank start %d\n", 1731 pipe, vpos); 1732 1733 /* Bump counter if we are at >= leading edge of vblank, 1734 * but before vsync where vpos would turn negative and 1735 * the hw counter really increments. 1736 */ 1737 if (vpos >= 0) 1738 count++; 1739 } 1740 } else { 1741 /* Fallback to use value as is. */ 1742 count = amdgpu_display_vblank_get_counter(adev, pipe); 1743 DRM_DEBUG_VBL("NULL mode info! Returned count may be wrong.\n"); 1744 } 1745 1746 up_read(&adev->reset_domain->sem); 1747 return count; 1748 } 1749 1750 /** 1751 * amdgpu_enable_vblank_kms - enable vblank interrupt 1752 * 1753 * @crtc: crtc to enable vblank interrupt for 1754 * 1755 * Enable the interrupt on the requested crtc (all asics). 1756 * Returns 0 on success, -EINVAL on failure. 1757 */ 1758 int amdgpu_enable_vblank_kms(struct drm_crtc *crtc) 1759 { 1760 struct drm_device *dev = crtc->dev; 1761 unsigned int pipe = crtc->index; 1762 struct amdgpu_device *adev = drm_to_adev(dev); 1763 int idx = amdgpu_display_crtc_idx_to_irq_type(adev, pipe); 1764 1765 return amdgpu_irq_get(adev, &adev->crtc_irq, idx); 1766 } 1767 1768 /** 1769 * amdgpu_disable_vblank_kms - disable vblank interrupt 1770 * 1771 * @crtc: crtc to disable vblank interrupt for 1772 * 1773 * Disable the interrupt on the requested crtc (all asics). 1774 */ 1775 void amdgpu_disable_vblank_kms(struct drm_crtc *crtc) 1776 { 1777 struct drm_device *dev = crtc->dev; 1778 unsigned int pipe = crtc->index; 1779 struct amdgpu_device *adev = drm_to_adev(dev); 1780 int idx = amdgpu_display_crtc_idx_to_irq_type(adev, pipe); 1781 1782 amdgpu_irq_put(adev, &adev->crtc_irq, idx); 1783 } 1784 1785 /* 1786 * Debugfs info 1787 */ 1788 #if defined(CONFIG_DEBUG_FS) 1789 1790 static int amdgpu_debugfs_firmware_info_show(struct seq_file *m, void *unused) 1791 { 1792 struct amdgpu_device *adev = m->private; 1793 struct drm_amdgpu_info_firmware fw_info; 1794 struct drm_amdgpu_query_fw query_fw; 1795 struct atom_context *ctx = adev->mode_info.atom_context; 1796 uint8_t smu_program, smu_major, smu_minor, smu_debug; 1797 int ret, i; 1798 1799 static const char *ta_fw_name[TA_FW_TYPE_MAX_INDEX] = { 1800 #define TA_FW_NAME(type)[TA_FW_TYPE_PSP_##type] = #type 1801 TA_FW_NAME(XGMI), 1802 TA_FW_NAME(RAS), 1803 TA_FW_NAME(HDCP), 1804 TA_FW_NAME(DTM), 1805 TA_FW_NAME(RAP), 1806 TA_FW_NAME(SECUREDISPLAY), 1807 #undef TA_FW_NAME 1808 }; 1809 1810 /* VCE */ 1811 query_fw.fw_type = AMDGPU_INFO_FW_VCE; 1812 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1813 if (ret) 1814 return ret; 1815 seq_printf(m, "VCE feature version: %u, firmware version: 0x%08x\n", 1816 fw_info.feature, fw_info.ver); 1817 1818 /* UVD */ 1819 query_fw.fw_type = AMDGPU_INFO_FW_UVD; 1820 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1821 if (ret) 1822 return ret; 1823 seq_printf(m, "UVD feature version: %u, firmware version: 0x%08x\n", 1824 fw_info.feature, fw_info.ver); 1825 1826 /* GMC */ 1827 query_fw.fw_type = AMDGPU_INFO_FW_GMC; 1828 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1829 if (ret) 1830 return ret; 1831 seq_printf(m, "MC feature version: %u, firmware version: 0x%08x\n", 1832 fw_info.feature, fw_info.ver); 1833 1834 /* ME */ 1835 query_fw.fw_type = AMDGPU_INFO_FW_GFX_ME; 1836 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1837 if (ret) 1838 return ret; 1839 seq_printf(m, "ME feature version: %u, firmware version: 0x%08x\n", 1840 fw_info.feature, fw_info.ver); 1841 1842 /* PFP */ 1843 query_fw.fw_type = AMDGPU_INFO_FW_GFX_PFP; 1844 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1845 if (ret) 1846 return ret; 1847 seq_printf(m, "PFP feature version: %u, firmware version: 0x%08x\n", 1848 fw_info.feature, fw_info.ver); 1849 1850 /* CE */ 1851 query_fw.fw_type = AMDGPU_INFO_FW_GFX_CE; 1852 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1853 if (ret) 1854 return ret; 1855 seq_printf(m, "CE feature version: %u, firmware version: 0x%08x\n", 1856 fw_info.feature, fw_info.ver); 1857 1858 /* RLC */ 1859 query_fw.fw_type = AMDGPU_INFO_FW_GFX_RLC; 1860 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1861 if (ret) 1862 return ret; 1863 seq_printf(m, "RLC feature version: %u, firmware version: 0x%08x\n", 1864 fw_info.feature, fw_info.ver); 1865 1866 /* RLC SAVE RESTORE LIST CNTL */ 1867 query_fw.fw_type = AMDGPU_INFO_FW_GFX_RLC_RESTORE_LIST_CNTL; 1868 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1869 if (ret) 1870 return ret; 1871 seq_printf(m, "RLC SRLC feature version: %u, firmware version: 0x%08x\n", 1872 fw_info.feature, fw_info.ver); 1873 1874 /* RLC SAVE RESTORE LIST GPM MEM */ 1875 query_fw.fw_type = AMDGPU_INFO_FW_GFX_RLC_RESTORE_LIST_GPM_MEM; 1876 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1877 if (ret) 1878 return ret; 1879 seq_printf(m, "RLC SRLG feature version: %u, firmware version: 0x%08x\n", 1880 fw_info.feature, fw_info.ver); 1881 1882 /* RLC SAVE RESTORE LIST SRM MEM */ 1883 query_fw.fw_type = AMDGPU_INFO_FW_GFX_RLC_RESTORE_LIST_SRM_MEM; 1884 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1885 if (ret) 1886 return ret; 1887 seq_printf(m, "RLC SRLS feature version: %u, firmware version: 0x%08x\n", 1888 fw_info.feature, fw_info.ver); 1889 1890 /* RLCP */ 1891 query_fw.fw_type = AMDGPU_INFO_FW_GFX_RLCP; 1892 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1893 if (ret) 1894 return ret; 1895 seq_printf(m, "RLCP feature version: %u, firmware version: 0x%08x\n", 1896 fw_info.feature, fw_info.ver); 1897 1898 /* RLCV */ 1899 query_fw.fw_type = AMDGPU_INFO_FW_GFX_RLCV; 1900 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1901 if (ret) 1902 return ret; 1903 seq_printf(m, "RLCV feature version: %u, firmware version: 0x%08x\n", 1904 fw_info.feature, fw_info.ver); 1905 1906 /* MEC */ 1907 query_fw.fw_type = AMDGPU_INFO_FW_GFX_MEC; 1908 query_fw.index = 0; 1909 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1910 if (ret) 1911 return ret; 1912 seq_printf(m, "MEC feature version: %u, firmware version: 0x%08x\n", 1913 fw_info.feature, fw_info.ver); 1914 1915 /* MEC2 */ 1916 if (adev->gfx.mec2_fw) { 1917 query_fw.index = 1; 1918 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1919 if (ret) 1920 return ret; 1921 seq_printf(m, "MEC2 feature version: %u, firmware version: 0x%08x\n", 1922 fw_info.feature, fw_info.ver); 1923 } 1924 1925 /* IMU */ 1926 query_fw.fw_type = AMDGPU_INFO_FW_IMU; 1927 query_fw.index = 0; 1928 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1929 if (ret) 1930 return ret; 1931 seq_printf(m, "IMU feature version: %u, firmware version: 0x%08x\n", 1932 fw_info.feature, fw_info.ver); 1933 1934 /* PSP SOS */ 1935 query_fw.fw_type = AMDGPU_INFO_FW_SOS; 1936 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1937 if (ret) 1938 return ret; 1939 seq_printf(m, "SOS feature version: %u, firmware version: 0x%08x\n", 1940 fw_info.feature, fw_info.ver); 1941 1942 1943 /* PSP ASD */ 1944 query_fw.fw_type = AMDGPU_INFO_FW_ASD; 1945 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1946 if (ret) 1947 return ret; 1948 seq_printf(m, "ASD feature version: %u, firmware version: 0x%08x\n", 1949 fw_info.feature, fw_info.ver); 1950 1951 query_fw.fw_type = AMDGPU_INFO_FW_TA; 1952 for (i = TA_FW_TYPE_PSP_XGMI; i < TA_FW_TYPE_MAX_INDEX; i++) { 1953 query_fw.index = i; 1954 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1955 if (ret) 1956 continue; 1957 1958 seq_printf(m, "TA %s feature version: 0x%08x, firmware version: 0x%08x\n", 1959 ta_fw_name[i], fw_info.feature, fw_info.ver); 1960 } 1961 1962 /* SMC */ 1963 query_fw.fw_type = AMDGPU_INFO_FW_SMC; 1964 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1965 if (ret) 1966 return ret; 1967 smu_program = (fw_info.ver >> 24) & 0xff; 1968 smu_major = (fw_info.ver >> 16) & 0xff; 1969 smu_minor = (fw_info.ver >> 8) & 0xff; 1970 smu_debug = (fw_info.ver >> 0) & 0xff; 1971 seq_printf(m, "SMC feature version: %u, program: %d, firmware version: 0x%08x (%d.%d.%d)\n", 1972 fw_info.feature, smu_program, fw_info.ver, smu_major, smu_minor, smu_debug); 1973 1974 /* MP5 */ 1975 query_fw.fw_type = AMDGPU_INFO_FW_MP5; 1976 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1977 if (ret) 1978 return ret; 1979 seq_printf(m, "MP5 feature version: %u, firmware version: 0x%08x\n", 1980 fw_info.feature, fw_info.ver); 1981 1982 /* SDMA */ 1983 query_fw.fw_type = AMDGPU_INFO_FW_SDMA; 1984 for (i = 0; i < adev->sdma.num_instances; i++) { 1985 query_fw.index = i; 1986 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1987 if (ret) 1988 return ret; 1989 seq_printf(m, "SDMA%d feature version: %u, firmware version: 0x%08x\n", 1990 i, fw_info.feature, fw_info.ver); 1991 } 1992 1993 /* VCN */ 1994 query_fw.fw_type = AMDGPU_INFO_FW_VCN; 1995 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 1996 if (ret) 1997 return ret; 1998 seq_printf(m, "VCN feature version: %u, firmware version: 0x%08x\n", 1999 fw_info.feature, fw_info.ver); 2000 2001 /* DMCU */ 2002 query_fw.fw_type = AMDGPU_INFO_FW_DMCU; 2003 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 2004 if (ret) 2005 return ret; 2006 seq_printf(m, "DMCU feature version: %u, firmware version: 0x%08x\n", 2007 fw_info.feature, fw_info.ver); 2008 2009 /* DMCUB */ 2010 query_fw.fw_type = AMDGPU_INFO_FW_DMCUB; 2011 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 2012 if (ret) 2013 return ret; 2014 seq_printf(m, "DMCUB feature version: %u, firmware version: 0x%08x\n", 2015 fw_info.feature, fw_info.ver); 2016 2017 /* TOC */ 2018 query_fw.fw_type = AMDGPU_INFO_FW_TOC; 2019 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 2020 if (ret) 2021 return ret; 2022 seq_printf(m, "TOC feature version: %u, firmware version: 0x%08x\n", 2023 fw_info.feature, fw_info.ver); 2024 2025 /* CAP */ 2026 if (adev->psp.cap_fw) { 2027 query_fw.fw_type = AMDGPU_INFO_FW_CAP; 2028 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 2029 if (ret) 2030 return ret; 2031 seq_printf(m, "CAP feature version: %u, firmware version: 0x%08x\n", 2032 fw_info.feature, fw_info.ver); 2033 } 2034 2035 /* MES_KIQ */ 2036 query_fw.fw_type = AMDGPU_INFO_FW_MES_KIQ; 2037 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 2038 if (ret) 2039 return ret; 2040 seq_printf(m, "MES_KIQ feature version: %u, firmware version: 0x%08x\n", 2041 fw_info.feature, fw_info.ver); 2042 2043 /* MES */ 2044 query_fw.fw_type = AMDGPU_INFO_FW_MES; 2045 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 2046 if (ret) 2047 return ret; 2048 seq_printf(m, "MES feature version: %u, firmware version: 0x%08x\n", 2049 fw_info.feature, fw_info.ver); 2050 2051 /* VPE */ 2052 query_fw.fw_type = AMDGPU_INFO_FW_VPE; 2053 ret = amdgpu_firmware_info(&fw_info, &query_fw, adev); 2054 if (ret) 2055 return ret; 2056 seq_printf(m, "VPE feature version: %u, firmware version: 0x%08x\n", 2057 fw_info.feature, fw_info.ver); 2058 2059 seq_printf(m, "VBIOS version: %s\n", ctx->vbios_pn); 2060 2061 return 0; 2062 } 2063 2064 DEFINE_SHOW_ATTRIBUTE(amdgpu_debugfs_firmware_info); 2065 2066 #endif 2067 2068 void amdgpu_debugfs_firmware_init(struct amdgpu_device *adev) 2069 { 2070 #if defined(CONFIG_DEBUG_FS) 2071 struct drm_minor *minor = adev_to_drm(adev)->primary; 2072 struct dentry *root = minor->debugfs_root; 2073 2074 debugfs_create_file("amdgpu_firmware_info", 0444, root, 2075 adev, &amdgpu_debugfs_firmware_info_fops); 2076 2077 #endif 2078 } 2079