amd-drm-next-6.7-2023-11-03:
amdgpu: - Fix RAS support check - RAS fixes - MES fixes - SMU13 fixes - Contiguous memory allocation fix - BACO fixes - GPU reset fixes - Min power limit fixes - GFX11 fixes - USB4/TB hotplug fixes - ARM regression fix - GFX9.4.3 fixes - KASAN/KCSAN stack size check fixes - SR-IOV fixes - SMU14 fixes - PSP13 fixes - Display blend fixes - Flexible array size fixes amdkfd: - GPUVM fix radeon: - Flexible array size fixes -----BEGIN PGP SIGNATURE----- iHUEABYKAB0WIQQgO5Idg2tXNTSZAr293/aFa7yZ2AUCZUUr4AAKCRC93/aFa7yZ 2EycAQChYxkqbqfKqhJrU7lyz8EEBybis8UzshmHZnCCQF7ZGgD/a8UUhjr/7itI 0n/hVEuu0sOVGaC8UQ0M8bl10NTvigI= =9rw/ -----END PGP SIGNATURE----- Merge tag 'amd-drm-next-6.7-2023-11-03' of https://gitlab.freedesktop.org/agd5f/linux into drm-next amd-drm-next-6.7-2023-11-03: amdgpu: - Fix RAS support check - RAS fixes - MES fixes - SMU13 fixes - Contiguous memory allocation fix - BACO fixes - GPU reset fixes - Min power limit fixes - GFX11 fixes - USB4/TB hotplug fixes - ARM regression fix - GFX9.4.3 fixes - KASAN/KCSAN stack size check fixes - SR-IOV fixes - SMU14 fixes - PSP13 fixes - Display blend fixes - Flexible array size fixes amdkfd: - GPUVM fix radeon: - Flexible array size fixes Signed-off-by: Dave Airlie <airlied@redhat.com> From: Alex Deucher <alexander.deucher@amd.com> Link: https://patchwork.freedesktop.org/patch/msgid/20231103173203.4912-1-alexander.deucher@amd.com
This commit is contained in:
commit
9ccde17d46
@ -363,9 +363,6 @@ struct amdgpu_ip_block_version {
|
||||
const struct amd_ip_funcs *funcs;
|
||||
};
|
||||
|
||||
#define HW_REV(_Major, _Minor, _Rev) \
|
||||
((((uint32_t) (_Major)) << 16) | ((uint32_t) (_Minor) << 8) | ((uint32_t) (_Rev)))
|
||||
|
||||
struct amdgpu_ip_block {
|
||||
struct amdgpu_ip_block_status status;
|
||||
const struct amdgpu_ip_block_version *version;
|
||||
|
@ -425,6 +425,32 @@ validate_fail:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int amdgpu_amdkfd_bo_validate_and_fence(struct amdgpu_bo *bo,
|
||||
uint32_t domain,
|
||||
struct dma_fence *fence)
|
||||
{
|
||||
int ret = amdgpu_bo_reserve(bo, false);
|
||||
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = amdgpu_amdkfd_bo_validate(bo, domain, true);
|
||||
if (ret)
|
||||
goto unreserve_out;
|
||||
|
||||
ret = dma_resv_reserve_fences(bo->tbo.base.resv, 1);
|
||||
if (ret)
|
||||
goto unreserve_out;
|
||||
|
||||
dma_resv_add_fence(bo->tbo.base.resv, fence,
|
||||
DMA_RESV_USAGE_BOOKKEEP);
|
||||
|
||||
unreserve_out:
|
||||
amdgpu_bo_unreserve(bo);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int amdgpu_amdkfd_validate_vm_bo(void *_unused, struct amdgpu_bo *bo)
|
||||
{
|
||||
return amdgpu_amdkfd_bo_validate(bo, bo->allowed_domains, false);
|
||||
@ -1784,6 +1810,15 @@ int amdgpu_amdkfd_gpuvm_alloc_memory_of_gpu(
|
||||
}
|
||||
bo->allowed_domains = AMDGPU_GEM_DOMAIN_GTT;
|
||||
bo->preferred_domains = AMDGPU_GEM_DOMAIN_GTT;
|
||||
} else {
|
||||
mutex_lock(&avm->process_info->lock);
|
||||
if (avm->process_info->eviction_fence &&
|
||||
!dma_fence_is_signaled(&avm->process_info->eviction_fence->base))
|
||||
ret = amdgpu_amdkfd_bo_validate_and_fence(bo, domain,
|
||||
&avm->process_info->eviction_fence->base);
|
||||
mutex_unlock(&avm->process_info->lock);
|
||||
if (ret)
|
||||
goto err_validate_bo;
|
||||
}
|
||||
|
||||
if (offset)
|
||||
@ -1793,6 +1828,7 @@ int amdgpu_amdkfd_gpuvm_alloc_memory_of_gpu(
|
||||
|
||||
allocate_init_user_pages_failed:
|
||||
err_pin_bo:
|
||||
err_validate_bo:
|
||||
remove_kgd_mem_from_kfd_bo_list(*mem, avm->process_info);
|
||||
drm_vma_node_revoke(&gobj->vma_node, drm_priv);
|
||||
err_node_allow:
|
||||
@ -1866,10 +1902,6 @@ int amdgpu_amdkfd_gpuvm_free_memory_of_gpu(
|
||||
if (unlikely(ret))
|
||||
return ret;
|
||||
|
||||
/* The eviction fence should be removed by the last unmap.
|
||||
* TODO: Log an error condition if the bo still has the eviction fence
|
||||
* attached
|
||||
*/
|
||||
amdgpu_amdkfd_remove_eviction_fence(mem->bo,
|
||||
process_info->eviction_fence);
|
||||
pr_debug("Release VA 0x%llx - 0x%llx\n", mem->va,
|
||||
@ -1998,19 +2030,6 @@ int amdgpu_amdkfd_gpuvm_map_memory_to_gpu(
|
||||
if (unlikely(ret))
|
||||
goto out_unreserve;
|
||||
|
||||
if (mem->mapped_to_gpu_memory == 0 &&
|
||||
!amdgpu_ttm_tt_get_usermm(bo->tbo.ttm)) {
|
||||
/* Validate BO only once. The eviction fence gets added to BO
|
||||
* the first time it is mapped. Validate will wait for all
|
||||
* background evictions to complete.
|
||||
*/
|
||||
ret = amdgpu_amdkfd_bo_validate(bo, domain, true);
|
||||
if (ret) {
|
||||
pr_debug("Validate failed\n");
|
||||
goto out_unreserve;
|
||||
}
|
||||
}
|
||||
|
||||
list_for_each_entry(entry, &mem->attachments, list) {
|
||||
if (entry->bo_va->base.vm != avm || entry->is_mapped)
|
||||
continue;
|
||||
@ -2037,10 +2056,6 @@ int amdgpu_amdkfd_gpuvm_map_memory_to_gpu(
|
||||
mem->mapped_to_gpu_memory);
|
||||
}
|
||||
|
||||
if (!amdgpu_ttm_tt_get_usermm(bo->tbo.ttm) && !bo->tbo.pin_count)
|
||||
dma_resv_add_fence(bo->tbo.base.resv,
|
||||
&avm->process_info->eviction_fence->base,
|
||||
DMA_RESV_USAGE_BOOKKEEP);
|
||||
ret = unreserve_bo_and_vms(&ctx, false, false);
|
||||
|
||||
goto out;
|
||||
@ -2074,7 +2089,6 @@ int amdgpu_amdkfd_gpuvm_unmap_memory_from_gpu(
|
||||
struct amdgpu_device *adev, struct kgd_mem *mem, void *drm_priv)
|
||||
{
|
||||
struct amdgpu_vm *avm = drm_priv_to_vm(drm_priv);
|
||||
struct amdkfd_process_info *process_info = avm->process_info;
|
||||
unsigned long bo_size = mem->bo->tbo.base.size;
|
||||
struct kfd_mem_attachment *entry;
|
||||
struct bo_vm_reservation_context ctx;
|
||||
@ -2115,15 +2129,6 @@ int amdgpu_amdkfd_gpuvm_unmap_memory_from_gpu(
|
||||
mem->mapped_to_gpu_memory);
|
||||
}
|
||||
|
||||
/* If BO is unmapped from all VMs, unfence it. It can be evicted if
|
||||
* required.
|
||||
*/
|
||||
if (mem->mapped_to_gpu_memory == 0 &&
|
||||
!amdgpu_ttm_tt_get_usermm(mem->bo->tbo.ttm) &&
|
||||
!mem->bo->tbo.pin_count)
|
||||
amdgpu_amdkfd_remove_eviction_fence(mem->bo,
|
||||
process_info->eviction_fence);
|
||||
|
||||
unreserve_out:
|
||||
unreserve_bo_and_vms(&ctx, false, false);
|
||||
out:
|
||||
@ -2351,8 +2356,20 @@ int amdgpu_amdkfd_gpuvm_import_dmabuf(struct amdgpu_device *adev,
|
||||
amdgpu_sync_create(&(*mem)->sync);
|
||||
(*mem)->is_imported = true;
|
||||
|
||||
mutex_lock(&avm->process_info->lock);
|
||||
if (avm->process_info->eviction_fence &&
|
||||
!dma_fence_is_signaled(&avm->process_info->eviction_fence->base))
|
||||
ret = amdgpu_amdkfd_bo_validate_and_fence(bo, (*mem)->domain,
|
||||
&avm->process_info->eviction_fence->base);
|
||||
mutex_unlock(&avm->process_info->lock);
|
||||
if (ret)
|
||||
goto err_remove_mem;
|
||||
|
||||
return 0;
|
||||
|
||||
err_remove_mem:
|
||||
remove_kgd_mem_from_kfd_bo_list(*mem, avm->process_info);
|
||||
drm_vma_node_revoke(&obj->vma_node, drm_priv);
|
||||
err_free_mem:
|
||||
kfree(*mem);
|
||||
err_put_obj:
|
||||
|
@ -29,6 +29,7 @@
|
||||
#include "amdgpu.h"
|
||||
#include "atom.h"
|
||||
|
||||
#include <linux/device.h>
|
||||
#include <linux/pci.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/acpi.h>
|
||||
@ -287,6 +288,10 @@ static bool amdgpu_atrm_get_bios(struct amdgpu_device *adev)
|
||||
if (adev->flags & AMD_IS_APU)
|
||||
return false;
|
||||
|
||||
/* ATRM is for on-platform devices only */
|
||||
if (dev_is_removable(&adev->pdev->dev))
|
||||
return false;
|
||||
|
||||
while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {
|
||||
dhandle = ACPI_HANDLE(&pdev->dev);
|
||||
if (!dhandle)
|
||||
|
@ -1116,6 +1116,11 @@ static int amdgpu_cs_vm_handling(struct amdgpu_cs_parser *p)
|
||||
return r;
|
||||
}
|
||||
|
||||
/* FIXME: In theory this loop shouldn't be needed any more when
|
||||
* amdgpu_vm_handle_moved handles all moved BOs that are reserved
|
||||
* with p->ticket. But removing it caused test regressions, so I'm
|
||||
* leaving it here for now.
|
||||
*/
|
||||
amdgpu_bo_list_for_each_entry(e, p->bo_list) {
|
||||
bo_va = e->bo_va;
|
||||
if (bo_va == NULL)
|
||||
@ -1130,7 +1135,7 @@ static int amdgpu_cs_vm_handling(struct amdgpu_cs_parser *p)
|
||||
return r;
|
||||
}
|
||||
|
||||
r = amdgpu_vm_handle_moved(adev, vm);
|
||||
r = amdgpu_vm_handle_moved(adev, vm, &p->exec.ticket);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
|
@ -41,6 +41,7 @@
|
||||
#include <drm/drm_fb_helper.h>
|
||||
#include <drm/drm_probe_helper.h>
|
||||
#include <drm/amdgpu_drm.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/vgaarb.h>
|
||||
#include <linux/vga_switcheroo.h>
|
||||
#include <linux/efi.h>
|
||||
@ -1073,6 +1074,8 @@ static int amdgpu_device_asic_init(struct amdgpu_device *adev)
|
||||
amdgpu_ip_version(adev, GC_HWIP, 0) >= IP_VERSION(11, 0, 0)) {
|
||||
amdgpu_psp_wait_for_bootloader(adev);
|
||||
ret = amdgpu_atomfirmware_asic_init(adev, true);
|
||||
/* TODO: check the return val and stop device initialization if boot fails */
|
||||
amdgpu_psp_query_boot_status(adev);
|
||||
return ret;
|
||||
} else {
|
||||
return amdgpu_atom_asic_init(adev->mode_info.atom_context);
|
||||
@ -2223,7 +2226,6 @@ out:
|
||||
*/
|
||||
static int amdgpu_device_ip_early_init(struct amdgpu_device *adev)
|
||||
{
|
||||
struct drm_device *dev = adev_to_drm(adev);
|
||||
struct pci_dev *parent;
|
||||
int i, r;
|
||||
bool total;
|
||||
@ -2294,7 +2296,7 @@ static int amdgpu_device_ip_early_init(struct amdgpu_device *adev)
|
||||
(amdgpu_is_atpx_hybrid() ||
|
||||
amdgpu_has_atpx_dgpu_power_cntl()) &&
|
||||
((adev->flags & AMD_IS_APU) == 0) &&
|
||||
!pci_is_thunderbolt_attached(to_pci_dev(dev->dev)))
|
||||
!dev_is_removable(&adev->pdev->dev))
|
||||
adev->flags |= AMD_IS_PX;
|
||||
|
||||
if (!(adev->flags & AMD_IS_APU)) {
|
||||
@ -3962,13 +3964,23 @@ int amdgpu_device_init(struct amdgpu_device *adev,
|
||||
}
|
||||
}
|
||||
} else {
|
||||
tmp = amdgpu_reset_method;
|
||||
/* It should do a default reset when loading or reloading the driver,
|
||||
* regardless of the module parameter reset_method.
|
||||
*/
|
||||
amdgpu_reset_method = AMD_RESET_METHOD_NONE;
|
||||
r = amdgpu_asic_reset(adev);
|
||||
amdgpu_reset_method = tmp;
|
||||
switch (amdgpu_ip_version(adev, MP1_HWIP, 0)) {
|
||||
case IP_VERSION(13, 0, 0):
|
||||
case IP_VERSION(13, 0, 7):
|
||||
case IP_VERSION(13, 0, 10):
|
||||
r = psp_gpu_reset(adev);
|
||||
break;
|
||||
default:
|
||||
tmp = amdgpu_reset_method;
|
||||
/* It should do a default reset when loading or reloading the driver,
|
||||
* regardless of the module parameter reset_method.
|
||||
*/
|
||||
amdgpu_reset_method = AMD_RESET_METHOD_NONE;
|
||||
r = amdgpu_asic_reset(adev);
|
||||
amdgpu_reset_method = tmp;
|
||||
break;
|
||||
}
|
||||
|
||||
if (r) {
|
||||
dev_err(adev->dev, "asic reset on init failed\n");
|
||||
goto failed;
|
||||
@ -4132,7 +4144,7 @@ fence_driver_init:
|
||||
|
||||
px = amdgpu_device_supports_px(ddev);
|
||||
|
||||
if (px || (!pci_is_thunderbolt_attached(adev->pdev) &&
|
||||
if (px || (!dev_is_removable(&adev->pdev->dev) &&
|
||||
apple_gmux_detect(NULL, NULL)))
|
||||
vga_switcheroo_register_client(adev->pdev,
|
||||
&amdgpu_switcheroo_ops, px);
|
||||
@ -4282,7 +4294,7 @@ void amdgpu_device_fini_sw(struct amdgpu_device *adev)
|
||||
|
||||
px = amdgpu_device_supports_px(adev_to_drm(adev));
|
||||
|
||||
if (px || (!pci_is_thunderbolt_attached(adev->pdev) &&
|
||||
if (px || (!dev_is_removable(&adev->pdev->dev) &&
|
||||
apple_gmux_detect(NULL, NULL)))
|
||||
vga_switcheroo_unregister_client(adev->pdev);
|
||||
|
||||
@ -5566,10 +5578,6 @@ skip_hw_reset:
|
||||
drm_sched_start(&ring->sched, true);
|
||||
}
|
||||
|
||||
if (adev->enable_mes &&
|
||||
amdgpu_ip_version(adev, GC_HWIP, 0) != IP_VERSION(11, 0, 3))
|
||||
amdgpu_mes_self_test(tmp_adev);
|
||||
|
||||
if (!drm_drv_uses_atomic_modeset(adev_to_drm(tmp_adev)) && !job_signaled)
|
||||
drm_helper_resume_force_mode(adev_to_drm(tmp_adev));
|
||||
|
||||
|
@ -99,6 +99,7 @@
|
||||
MODULE_FIRMWARE(FIRMWARE_IP_DISCOVERY);
|
||||
|
||||
#define mmRCC_CONFIG_MEMSIZE 0xde3
|
||||
#define mmMP0_SMN_C2PMSG_33 0x16061
|
||||
#define mmMM_INDEX 0x0
|
||||
#define mmMM_INDEX_HI 0x6
|
||||
#define mmMM_DATA 0x1
|
||||
@ -239,8 +240,26 @@ static int amdgpu_discovery_read_binary_from_sysmem(struct amdgpu_device *adev,
|
||||
static int amdgpu_discovery_read_binary_from_mem(struct amdgpu_device *adev,
|
||||
uint8_t *binary)
|
||||
{
|
||||
uint64_t vram_size = (uint64_t)RREG32(mmRCC_CONFIG_MEMSIZE) << 20;
|
||||
int ret = 0;
|
||||
uint64_t vram_size;
|
||||
u32 msg;
|
||||
int i, ret = 0;
|
||||
|
||||
/* It can take up to a second for IFWI init to complete on some dGPUs,
|
||||
* but generally it should be in the 60-100ms range. Normally this starts
|
||||
* as soon as the device gets power so by the time the OS loads this has long
|
||||
* completed. However, when a card is hotplugged via e.g., USB4, we need to
|
||||
* wait for this to complete. Once the C2PMSG is updated, we can
|
||||
* continue.
|
||||
*/
|
||||
if (dev_is_removable(&adev->pdev->dev)) {
|
||||
for (i = 0; i < 1000; i++) {
|
||||
msg = RREG32(mmMP0_SMN_C2PMSG_33);
|
||||
if (msg & 0x80000000)
|
||||
break;
|
||||
msleep(1);
|
||||
}
|
||||
}
|
||||
vram_size = (uint64_t)RREG32(mmRCC_CONFIG_MEMSIZE) << 20;
|
||||
|
||||
if (vram_size) {
|
||||
uint64_t pos = vram_size - DISCOVERY_TMR_OFFSET;
|
||||
@ -2449,6 +2468,9 @@ int amdgpu_discovery_set_ip_blocks(struct amdgpu_device *adev)
|
||||
if (amdgpu_ip_version(adev, XGMI_HWIP, 0) == IP_VERSION(4, 8, 0))
|
||||
adev->gmc.xgmi.supported = true;
|
||||
|
||||
if (amdgpu_ip_version(adev, GC_HWIP, 0) == IP_VERSION(9, 4, 3))
|
||||
adev->ip_versions[XGMI_HWIP][0] = IP_VERSION(6, 4, 0);
|
||||
|
||||
/* set NBIO version */
|
||||
switch (amdgpu_ip_version(adev, NBIO_HWIP, 0)) {
|
||||
case IP_VERSION(6, 1, 0):
|
||||
|
@ -409,7 +409,7 @@ amdgpu_dma_buf_move_notify(struct dma_buf_attachment *attach)
|
||||
if (!r)
|
||||
r = amdgpu_vm_clear_freed(adev, vm, NULL);
|
||||
if (!r)
|
||||
r = amdgpu_vm_handle_moved(adev, vm);
|
||||
r = amdgpu_vm_handle_moved(adev, vm, ticket);
|
||||
|
||||
if (r && r != -EBUSY)
|
||||
DRM_ERROR("Failed to invalidate VM page tables (%d))\n",
|
||||
|
@ -2041,6 +2041,14 @@ static const struct pci_device_id pciidlist[] = {
|
||||
|
||||
MODULE_DEVICE_TABLE(pci, pciidlist);
|
||||
|
||||
static const struct amdgpu_asic_type_quirk asic_type_quirks[] = {
|
||||
/* differentiate between P10 and P11 asics with the same DID */
|
||||
{0x67FF, 0xE3, CHIP_POLARIS10},
|
||||
{0x67FF, 0xE7, CHIP_POLARIS10},
|
||||
{0x67FF, 0xF3, CHIP_POLARIS10},
|
||||
{0x67FF, 0xF7, CHIP_POLARIS10},
|
||||
};
|
||||
|
||||
static const struct drm_driver amdgpu_kms_driver;
|
||||
|
||||
static void amdgpu_get_secondary_funcs(struct amdgpu_device *adev)
|
||||
@ -2083,6 +2091,22 @@ static void amdgpu_init_debug_options(struct amdgpu_device *adev)
|
||||
}
|
||||
}
|
||||
|
||||
static unsigned long amdgpu_fix_asic_type(struct pci_dev *pdev, unsigned long flags)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(asic_type_quirks); i++) {
|
||||
if (pdev->device == asic_type_quirks[i].device &&
|
||||
pdev->revision == asic_type_quirks[i].revision) {
|
||||
flags &= ~AMD_ASIC_MASK;
|
||||
flags |= asic_type_quirks[i].type;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return flags;
|
||||
}
|
||||
|
||||
static int amdgpu_pci_probe(struct pci_dev *pdev,
|
||||
const struct pci_device_id *ent)
|
||||
{
|
||||
@ -2110,15 +2134,8 @@ static int amdgpu_pci_probe(struct pci_dev *pdev,
|
||||
"See modparam exp_hw_support\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
/* differentiate between P10 and P11 asics with the same DID */
|
||||
if (pdev->device == 0x67FF &&
|
||||
(pdev->revision == 0xE3 ||
|
||||
pdev->revision == 0xE7 ||
|
||||
pdev->revision == 0xF3 ||
|
||||
pdev->revision == 0xF7)) {
|
||||
flags &= ~AMD_ASIC_MASK;
|
||||
flags |= CHIP_POLARIS10;
|
||||
}
|
||||
|
||||
flags = amdgpu_fix_asic_type(pdev, flags);
|
||||
|
||||
/* Due to hardware bugs, S/G Display on raven requires a 1:1 IOMMU mapping,
|
||||
* however, SME requires an indirect IOMMU mapping because the encryption
|
||||
|
@ -385,9 +385,11 @@ int amdgpu_gfx_mqd_sw_init(struct amdgpu_device *adev,
|
||||
struct amdgpu_ring *ring = &kiq->ring;
|
||||
u32 domain = AMDGPU_GEM_DOMAIN_GTT;
|
||||
|
||||
#if !defined(CONFIG_ARM) && !defined(CONFIG_ARM64)
|
||||
/* Only enable on gfx10 and 11 for now to avoid changing behavior on older chips */
|
||||
if (amdgpu_ip_version(adev, GC_HWIP, 0) >= IP_VERSION(10, 0, 0))
|
||||
domain |= AMDGPU_GEM_DOMAIN_VRAM;
|
||||
#endif
|
||||
|
||||
/* create MQD for KIQ */
|
||||
if (!adev->enable_mes_kiq && !ring->mqd_obj) {
|
||||
|
@ -557,8 +557,20 @@ static void amdgpu_mes_queue_init_mqd(struct amdgpu_device *adev,
|
||||
mqd_prop.hqd_queue_priority = p->hqd_queue_priority;
|
||||
mqd_prop.hqd_active = false;
|
||||
|
||||
if (p->queue_type == AMDGPU_RING_TYPE_GFX ||
|
||||
p->queue_type == AMDGPU_RING_TYPE_COMPUTE) {
|
||||
mutex_lock(&adev->srbm_mutex);
|
||||
amdgpu_gfx_select_me_pipe_q(adev, p->ring->me, p->ring->pipe, 0, 0, 0);
|
||||
}
|
||||
|
||||
mqd_mgr->init_mqd(adev, q->mqd_cpu_ptr, &mqd_prop);
|
||||
|
||||
if (p->queue_type == AMDGPU_RING_TYPE_GFX ||
|
||||
p->queue_type == AMDGPU_RING_TYPE_COMPUTE) {
|
||||
amdgpu_gfx_select_me_pipe_q(adev, 0, 0, 0, 0, 0);
|
||||
mutex_unlock(&adev->srbm_mutex);
|
||||
}
|
||||
|
||||
amdgpu_bo_unreserve(q->mqd_obj);
|
||||
}
|
||||
|
||||
@ -994,9 +1006,13 @@ int amdgpu_mes_add_ring(struct amdgpu_device *adev, int gang_id,
|
||||
switch (queue_type) {
|
||||
case AMDGPU_RING_TYPE_GFX:
|
||||
ring->funcs = adev->gfx.gfx_ring[0].funcs;
|
||||
ring->me = adev->gfx.gfx_ring[0].me;
|
||||
ring->pipe = adev->gfx.gfx_ring[0].pipe;
|
||||
break;
|
||||
case AMDGPU_RING_TYPE_COMPUTE:
|
||||
ring->funcs = adev->gfx.compute_ring[0].funcs;
|
||||
ring->me = adev->gfx.compute_ring[0].me;
|
||||
ring->pipe = adev->gfx.compute_ring[0].pipe;
|
||||
break;
|
||||
case AMDGPU_RING_TYPE_SDMA:
|
||||
ring->funcs = adev->sdma.instance[0].ring.funcs;
|
||||
|
@ -2120,6 +2120,21 @@ int amdgpu_psp_wait_for_bootloader(struct amdgpu_device *adev)
|
||||
return ret;
|
||||
}
|
||||
|
||||
int amdgpu_psp_query_boot_status(struct amdgpu_device *adev)
|
||||
{
|
||||
struct psp_context *psp = &adev->psp;
|
||||
int ret = 0;
|
||||
|
||||
if (amdgpu_sriov_vf(adev) || (adev->flags & AMD_IS_APU))
|
||||
return 0;
|
||||
|
||||
if (psp->funcs &&
|
||||
psp->funcs->query_boot_status)
|
||||
ret = psp->funcs->query_boot_status(psp);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int psp_hw_start(struct psp_context *psp)
|
||||
{
|
||||
struct amdgpu_device *adev = psp->adev;
|
||||
|
@ -134,6 +134,7 @@ struct psp_funcs {
|
||||
int (*update_spirom)(struct psp_context *psp, uint64_t fw_pri_mc_addr);
|
||||
int (*vbflash_stat)(struct psp_context *psp);
|
||||
int (*fatal_error_recovery_quirk)(struct psp_context *psp);
|
||||
int (*query_boot_status)(struct psp_context *psp);
|
||||
};
|
||||
|
||||
struct ta_funcs {
|
||||
@ -537,4 +538,6 @@ int is_psp_fw_valid(struct psp_bin_desc bin);
|
||||
|
||||
int amdgpu_psp_wait_for_bootloader(struct amdgpu_device *adev);
|
||||
|
||||
int amdgpu_psp_query_boot_status(struct amdgpu_device *adev);
|
||||
|
||||
#endif
|
||||
|
@ -1222,6 +1222,8 @@ int amdgpu_ras_reset_error_count(struct amdgpu_device *adev,
|
||||
struct amdgpu_ras_block_object *block_obj = amdgpu_ras_get_ras_block(adev, block, 0);
|
||||
struct amdgpu_ras *ras = amdgpu_ras_get_context(adev);
|
||||
const struct amdgpu_mca_smu_funcs *mca_funcs = adev->mca.mca_funcs;
|
||||
struct amdgpu_hive_info *hive;
|
||||
int hive_ras_recovery = 0;
|
||||
|
||||
if (!block_obj || !block_obj->hw_ops) {
|
||||
dev_dbg_once(adev->dev, "%s doesn't config RAS function\n",
|
||||
@ -1229,15 +1231,22 @@ int amdgpu_ras_reset_error_count(struct amdgpu_device *adev,
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
||||
/* skip ras error reset in gpu reset */
|
||||
if ((amdgpu_in_reset(adev) || atomic_read(&ras->in_recovery)) &&
|
||||
mca_funcs && mca_funcs->mca_set_debug_mode)
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
if (!amdgpu_ras_is_supported(adev, block) ||
|
||||
!amdgpu_ras_get_mca_debug_mode(adev))
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
hive = amdgpu_get_xgmi_hive(adev);
|
||||
if (hive) {
|
||||
hive_ras_recovery = atomic_read(&hive->ras_recovery);
|
||||
amdgpu_put_xgmi_hive(hive);
|
||||
}
|
||||
|
||||
/* skip ras error reset in gpu reset */
|
||||
if ((amdgpu_in_reset(adev) || atomic_read(&ras->in_recovery) ||
|
||||
hive_ras_recovery) &&
|
||||
mca_funcs && mca_funcs->mca_set_debug_mode)
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
if (block_obj->hw_ops->reset_ras_error_count)
|
||||
block_obj->hw_ops->reset_ras_error_count(adev);
|
||||
|
||||
|
@ -166,8 +166,12 @@ static int amdgpu_umc_do_page_retirement(struct amdgpu_device *adev,
|
||||
}
|
||||
}
|
||||
|
||||
if (reset)
|
||||
if (reset) {
|
||||
/* use mode-2 reset for poison consumption */
|
||||
if (!entry)
|
||||
con->gpu_reset_flags |= AMDGPU_RAS_GPU_RESET_MODE2_RESET;
|
||||
amdgpu_ras_reset_gpu(adev);
|
||||
}
|
||||
}
|
||||
|
||||
kfree(err_data->err_addr);
|
||||
|
@ -1373,6 +1373,7 @@ int amdgpu_vm_clear_freed(struct amdgpu_device *adev,
|
||||
*
|
||||
* @adev: amdgpu_device pointer
|
||||
* @vm: requested vm
|
||||
* @ticket: optional reservation ticket used to reserve the VM
|
||||
*
|
||||
* Make sure all BOs which are moved are updated in the PTs.
|
||||
*
|
||||
@ -1382,11 +1383,12 @@ int amdgpu_vm_clear_freed(struct amdgpu_device *adev,
|
||||
* PTs have to be reserved!
|
||||
*/
|
||||
int amdgpu_vm_handle_moved(struct amdgpu_device *adev,
|
||||
struct amdgpu_vm *vm)
|
||||
struct amdgpu_vm *vm,
|
||||
struct ww_acquire_ctx *ticket)
|
||||
{
|
||||
struct amdgpu_bo_va *bo_va;
|
||||
struct dma_resv *resv;
|
||||
bool clear;
|
||||
bool clear, unlock;
|
||||
int r;
|
||||
|
||||
spin_lock(&vm->status_lock);
|
||||
@ -1409,17 +1411,24 @@ int amdgpu_vm_handle_moved(struct amdgpu_device *adev,
|
||||
spin_unlock(&vm->status_lock);
|
||||
|
||||
/* Try to reserve the BO to avoid clearing its ptes */
|
||||
if (!adev->debug_vm && dma_resv_trylock(resv))
|
||||
if (!adev->debug_vm && dma_resv_trylock(resv)) {
|
||||
clear = false;
|
||||
unlock = true;
|
||||
/* The caller is already holding the reservation lock */
|
||||
} else if (ticket && dma_resv_locking_ctx(resv) == ticket) {
|
||||
clear = false;
|
||||
unlock = false;
|
||||
/* Somebody else is using the BO right now */
|
||||
else
|
||||
} else {
|
||||
clear = true;
|
||||
unlock = false;
|
||||
}
|
||||
|
||||
r = amdgpu_vm_bo_update(adev, bo_va, clear);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
if (!clear)
|
||||
if (unlock)
|
||||
dma_resv_unlock(resv);
|
||||
spin_lock(&vm->status_lock);
|
||||
}
|
||||
|
@ -443,7 +443,8 @@ int amdgpu_vm_clear_freed(struct amdgpu_device *adev,
|
||||
struct amdgpu_vm *vm,
|
||||
struct dma_fence **fence);
|
||||
int amdgpu_vm_handle_moved(struct amdgpu_device *adev,
|
||||
struct amdgpu_vm *vm);
|
||||
struct amdgpu_vm *vm,
|
||||
struct ww_acquire_ctx *ticket);
|
||||
void amdgpu_vm_bo_base_init(struct amdgpu_vm_bo_base *base,
|
||||
struct amdgpu_vm *vm, struct amdgpu_bo *bo);
|
||||
int amdgpu_vm_update_range(struct amdgpu_device *adev, struct amdgpu_vm *vm,
|
||||
|
@ -77,7 +77,16 @@ static inline bool amdgpu_is_vram_mgr_blocks_contiguous(struct list_head *head)
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline u64 amdgpu_vram_mgr_blocks_size(struct list_head *head)
|
||||
{
|
||||
struct drm_buddy_block *block;
|
||||
u64 size = 0;
|
||||
|
||||
list_for_each_entry(block, head, link)
|
||||
size += amdgpu_vram_mgr_block_size(block);
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
/**
|
||||
* DOC: mem_info_vram_total
|
||||
@ -516,6 +525,8 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
|
||||
mutex_unlock(&mgr->lock);
|
||||
|
||||
vres->base.start = 0;
|
||||
size = max_t(u64, amdgpu_vram_mgr_blocks_size(&vres->blocks),
|
||||
vres->base.size);
|
||||
list_for_each_entry(block, &vres->blocks, link) {
|
||||
unsigned long start;
|
||||
|
||||
@ -523,8 +534,8 @@ static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
|
||||
amdgpu_vram_mgr_block_size(block);
|
||||
start >>= PAGE_SHIFT;
|
||||
|
||||
if (start > PFN_UP(vres->base.size))
|
||||
start -= PFN_UP(vres->base.size);
|
||||
if (start > PFN_UP(size))
|
||||
start -= PFN_UP(size);
|
||||
else
|
||||
start = 0;
|
||||
vres->base.start = max(vres->base.start, start);
|
||||
|
@ -3498,6 +3498,8 @@ static void gfx_v10_0_ring_invalidate_tlbs(struct amdgpu_ring *ring,
|
||||
static void gfx_v10_0_update_spm_vmid_internal(struct amdgpu_device *adev,
|
||||
unsigned int vmid);
|
||||
|
||||
static int gfx_v10_0_set_powergating_state(void *handle,
|
||||
enum amd_powergating_state state);
|
||||
static void gfx10_kiq_set_resources(struct amdgpu_ring *kiq_ring, uint64_t queue_mask)
|
||||
{
|
||||
amdgpu_ring_write(kiq_ring, PACKET3(PACKET3_SET_RESOURCES, 6));
|
||||
@ -6465,11 +6467,18 @@ static int gfx_v10_0_gfx_init_queue(struct amdgpu_ring *ring)
|
||||
nv_grbm_select(adev, 0, 0, 0, 0);
|
||||
mutex_unlock(&adev->srbm_mutex);
|
||||
if (adev->gfx.me.mqd_backup[mqd_idx])
|
||||
memcpy(adev->gfx.me.mqd_backup[mqd_idx], mqd, sizeof(*mqd));
|
||||
memcpy_fromio(adev->gfx.me.mqd_backup[mqd_idx], mqd, sizeof(*mqd));
|
||||
} else {
|
||||
mutex_lock(&adev->srbm_mutex);
|
||||
nv_grbm_select(adev, ring->me, ring->pipe, ring->queue, 0);
|
||||
if (ring->doorbell_index == adev->doorbell_index.gfx_ring0 << 1)
|
||||
gfx_v10_0_cp_gfx_set_doorbell(adev, ring);
|
||||
|
||||
nv_grbm_select(adev, 0, 0, 0, 0);
|
||||
mutex_unlock(&adev->srbm_mutex);
|
||||
/* restore mqd with the backup copy */
|
||||
if (adev->gfx.me.mqd_backup[mqd_idx])
|
||||
memcpy(mqd, adev->gfx.me.mqd_backup[mqd_idx], sizeof(*mqd));
|
||||
memcpy_toio(mqd, adev->gfx.me.mqd_backup[mqd_idx], sizeof(*mqd));
|
||||
/* reset the ring */
|
||||
ring->wptr = 0;
|
||||
*ring->wptr_cpu_addr = 0;
|
||||
@ -6743,7 +6752,7 @@ static int gfx_v10_0_kiq_init_queue(struct amdgpu_ring *ring)
|
||||
if (amdgpu_in_reset(adev)) { /* for GPU_RESET case */
|
||||
/* reset MQD to a clean status */
|
||||
if (adev->gfx.kiq[0].mqd_backup)
|
||||
memcpy(mqd, adev->gfx.kiq[0].mqd_backup, sizeof(*mqd));
|
||||
memcpy_toio(mqd, adev->gfx.kiq[0].mqd_backup, sizeof(*mqd));
|
||||
|
||||
/* reset ring buffer */
|
||||
ring->wptr = 0;
|
||||
@ -6766,7 +6775,7 @@ static int gfx_v10_0_kiq_init_queue(struct amdgpu_ring *ring)
|
||||
mutex_unlock(&adev->srbm_mutex);
|
||||
|
||||
if (adev->gfx.kiq[0].mqd_backup)
|
||||
memcpy(adev->gfx.kiq[0].mqd_backup, mqd, sizeof(*mqd));
|
||||
memcpy_fromio(adev->gfx.kiq[0].mqd_backup, mqd, sizeof(*mqd));
|
||||
}
|
||||
|
||||
return 0;
|
||||
@ -6787,11 +6796,11 @@ static int gfx_v10_0_kcq_init_queue(struct amdgpu_ring *ring)
|
||||
mutex_unlock(&adev->srbm_mutex);
|
||||
|
||||
if (adev->gfx.mec.mqd_backup[mqd_idx])
|
||||
memcpy(adev->gfx.mec.mqd_backup[mqd_idx], mqd, sizeof(*mqd));
|
||||
memcpy_fromio(adev->gfx.mec.mqd_backup[mqd_idx], mqd, sizeof(*mqd));
|
||||
} else {
|
||||
/* restore MQD to a clean status */
|
||||
if (adev->gfx.mec.mqd_backup[mqd_idx])
|
||||
memcpy(mqd, adev->gfx.mec.mqd_backup[mqd_idx], sizeof(*mqd));
|
||||
memcpy_toio(mqd, adev->gfx.mec.mqd_backup[mqd_idx], sizeof(*mqd));
|
||||
/* reset ring buffer */
|
||||
ring->wptr = 0;
|
||||
atomic64_set((atomic64_t *)ring->wptr_cpu_addr, 0);
|
||||
@ -7172,6 +7181,13 @@ static int gfx_v10_0_hw_fini(void *handle)
|
||||
amdgpu_irq_put(adev, &adev->gfx.priv_reg_irq, 0);
|
||||
amdgpu_irq_put(adev, &adev->gfx.priv_inst_irq, 0);
|
||||
|
||||
/* WA added for Vangogh asic fixing the SMU suspend failure
|
||||
* It needs to set power gating again during gfxoff control
|
||||
* otherwise the gfxoff disallowing will be failed to set.
|
||||
*/
|
||||
if (amdgpu_ip_version(adev, GC_HWIP, 0) == IP_VERSION(10, 3, 1))
|
||||
gfx_v10_0_set_powergating_state(handle, AMD_PG_STATE_UNGATE);
|
||||
|
||||
if (!adev->no_hw_access) {
|
||||
if (amdgpu_async_gfx_ring) {
|
||||
if (amdgpu_gfx_disable_kgq(adev, 0))
|
||||
|
@ -155,6 +155,7 @@ static void gfx11_kiq_set_resources(struct amdgpu_ring *kiq_ring, uint64_t queue
|
||||
{
|
||||
amdgpu_ring_write(kiq_ring, PACKET3(PACKET3_SET_RESOURCES, 6));
|
||||
amdgpu_ring_write(kiq_ring, PACKET3_SET_RESOURCES_VMID_MASK(0) |
|
||||
PACKET3_SET_RESOURCES_UNMAP_LATENTY(0xa) | /* unmap_latency: 0xa (~ 1s) */
|
||||
PACKET3_SET_RESOURCES_QUEUE_TYPE(0)); /* vmid_mask:0 queue_type:0 (KIQ) */
|
||||
amdgpu_ring_write(kiq_ring, lower_32_bits(queue_mask)); /* queue mask lo */
|
||||
amdgpu_ring_write(kiq_ring, upper_32_bits(queue_mask)); /* queue mask hi */
|
||||
@ -3714,11 +3715,11 @@ static int gfx_v11_0_gfx_init_queue(struct amdgpu_ring *ring)
|
||||
soc21_grbm_select(adev, 0, 0, 0, 0);
|
||||
mutex_unlock(&adev->srbm_mutex);
|
||||
if (adev->gfx.me.mqd_backup[mqd_idx])
|
||||
memcpy(adev->gfx.me.mqd_backup[mqd_idx], mqd, sizeof(*mqd));
|
||||
memcpy_fromio(adev->gfx.me.mqd_backup[mqd_idx], mqd, sizeof(*mqd));
|
||||
} else {
|
||||
/* restore mqd with the backup copy */
|
||||
if (adev->gfx.me.mqd_backup[mqd_idx])
|
||||
memcpy(mqd, adev->gfx.me.mqd_backup[mqd_idx], sizeof(*mqd));
|
||||
memcpy_toio(mqd, adev->gfx.me.mqd_backup[mqd_idx], sizeof(*mqd));
|
||||
/* reset the ring */
|
||||
ring->wptr = 0;
|
||||
*ring->wptr_cpu_addr = 0;
|
||||
@ -4007,7 +4008,7 @@ static int gfx_v11_0_kiq_init_queue(struct amdgpu_ring *ring)
|
||||
if (amdgpu_in_reset(adev)) { /* for GPU_RESET case */
|
||||
/* reset MQD to a clean status */
|
||||
if (adev->gfx.kiq[0].mqd_backup)
|
||||
memcpy(mqd, adev->gfx.kiq[0].mqd_backup, sizeof(*mqd));
|
||||
memcpy_toio(mqd, adev->gfx.kiq[0].mqd_backup, sizeof(*mqd));
|
||||
|
||||
/* reset ring buffer */
|
||||
ring->wptr = 0;
|
||||
@ -4030,7 +4031,7 @@ static int gfx_v11_0_kiq_init_queue(struct amdgpu_ring *ring)
|
||||
mutex_unlock(&adev->srbm_mutex);
|
||||
|
||||
if (adev->gfx.kiq[0].mqd_backup)
|
||||
memcpy(adev->gfx.kiq[0].mqd_backup, mqd, sizeof(*mqd));
|
||||
memcpy_fromio(adev->gfx.kiq[0].mqd_backup, mqd, sizeof(*mqd));
|
||||
}
|
||||
|
||||
return 0;
|
||||
@ -4051,11 +4052,11 @@ static int gfx_v11_0_kcq_init_queue(struct amdgpu_ring *ring)
|
||||
mutex_unlock(&adev->srbm_mutex);
|
||||
|
||||
if (adev->gfx.mec.mqd_backup[mqd_idx])
|
||||
memcpy(adev->gfx.mec.mqd_backup[mqd_idx], mqd, sizeof(*mqd));
|
||||
memcpy_fromio(adev->gfx.mec.mqd_backup[mqd_idx], mqd, sizeof(*mqd));
|
||||
} else {
|
||||
/* restore MQD to a clean status */
|
||||
if (adev->gfx.mec.mqd_backup[mqd_idx])
|
||||
memcpy(mqd, adev->gfx.mec.mqd_backup[mqd_idx], sizeof(*mqd));
|
||||
memcpy_toio(mqd, adev->gfx.mec.mqd_backup[mqd_idx], sizeof(*mqd));
|
||||
/* reset ring buffer */
|
||||
ring->wptr = 0;
|
||||
atomic64_set((atomic64_t *)ring->wptr_cpu_addr, 0);
|
||||
|
@ -28,6 +28,7 @@
|
||||
#include "nbio/nbio_2_3_offset.h"
|
||||
#include "nbio/nbio_2_3_sh_mask.h"
|
||||
#include <uapi/linux/kfd_ioctl.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/pci.h>
|
||||
|
||||
#define smnPCIE_CONFIG_CNTL 0x11180044
|
||||
@ -361,7 +362,7 @@ static void nbio_v2_3_enable_aspm(struct amdgpu_device *adev,
|
||||
|
||||
data |= NAVI10_PCIE__LC_L0S_INACTIVITY_DEFAULT << PCIE_LC_CNTL__LC_L0S_INACTIVITY__SHIFT;
|
||||
|
||||
if (pci_is_thunderbolt_attached(adev->pdev))
|
||||
if (dev_is_removable(&adev->pdev->dev))
|
||||
data |= NAVI10_PCIE__LC_L1_INACTIVITY_TBT_DEFAULT << PCIE_LC_CNTL__LC_L1_INACTIVITY__SHIFT;
|
||||
else
|
||||
data |= NAVI10_PCIE__LC_L1_INACTIVITY_DEFAULT << PCIE_LC_CNTL__LC_L1_INACTIVITY__SHIFT;
|
||||
@ -480,7 +481,7 @@ static void nbio_v2_3_program_aspm(struct amdgpu_device *adev)
|
||||
|
||||
def = data = RREG32_PCIE(smnPCIE_LC_CNTL);
|
||||
data |= NAVI10_PCIE__LC_L0S_INACTIVITY_DEFAULT << PCIE_LC_CNTL__LC_L0S_INACTIVITY__SHIFT;
|
||||
if (pci_is_thunderbolt_attached(adev->pdev))
|
||||
if (dev_is_removable(&adev->pdev->dev))
|
||||
data |= NAVI10_PCIE__LC_L1_INACTIVITY_TBT_DEFAULT << PCIE_LC_CNTL__LC_L1_INACTIVITY__SHIFT;
|
||||
else
|
||||
data |= NAVI10_PCIE__LC_L1_INACTIVITY_DEFAULT << PCIE_LC_CNTL__LC_L1_INACTIVITY__SHIFT;
|
||||
|
@ -759,6 +759,83 @@ static int psp_v13_0_fatal_error_recovery_quirk(struct psp_context *psp)
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static void psp_v13_0_boot_error_reporting(struct amdgpu_device *adev,
|
||||
uint32_t inst,
|
||||
uint32_t boot_error)
|
||||
{
|
||||
uint32_t socket_id;
|
||||
uint32_t aid_id;
|
||||
uint32_t hbm_id;
|
||||
uint32_t reg_data;
|
||||
|
||||
socket_id = REG_GET_FIELD(boot_error, MP0_SMN_C2PMSG_126, SOCKET_ID);
|
||||
aid_id = REG_GET_FIELD(boot_error, MP0_SMN_C2PMSG_126, AID_ID);
|
||||
hbm_id = REG_GET_FIELD(boot_error, MP0_SMN_C2PMSG_126, HBM_ID);
|
||||
|
||||
reg_data = RREG32_SOC15(MP0, inst, regMP0_SMN_C2PMSG_109);
|
||||
dev_info(adev->dev, "socket: %d, aid: %d, firmware boot failed, fw status is 0x%x\n",
|
||||
socket_id, aid_id, reg_data);
|
||||
|
||||
if (REG_GET_FIELD(boot_error, MP0_SMN_C2PMSG_126, GPU_ERR_MEM_TRAINING))
|
||||
dev_info(adev->dev, "socket: %d, aid: %d, hbm: %d, memory training failed\n",
|
||||
socket_id, aid_id, hbm_id);
|
||||
|
||||
if (REG_GET_FIELD(boot_error, MP0_SMN_C2PMSG_126, GPU_ERR_FW_LOAD))
|
||||
dev_info(adev->dev, "socket: %d, aid: %d, firmware load failed at boot time\n",
|
||||
socket_id, aid_id);
|
||||
|
||||
if (REG_GET_FIELD(boot_error, MP0_SMN_C2PMSG_126, GPU_ERR_WAFL_LINK_TRAINING))
|
||||
dev_info(adev->dev, "socket: %d, aid: %d, wafl link training failed\n",
|
||||
socket_id, aid_id);
|
||||
|
||||
if (REG_GET_FIELD(boot_error, MP0_SMN_C2PMSG_126, GPU_ERR_XGMI_LINK_TRAINING))
|
||||
dev_info(adev->dev, "socket: %d, aid: %d, xgmi link training failed\n",
|
||||
socket_id, aid_id);
|
||||
|
||||
if (REG_GET_FIELD(boot_error, MP0_SMN_C2PMSG_126, GPU_ERR_USR_CP_LINK_TRAINING))
|
||||
dev_info(adev->dev, "socket: %d, aid: %d, usr cp link training failed\n",
|
||||
socket_id, aid_id);
|
||||
|
||||
if (REG_GET_FIELD(boot_error, MP0_SMN_C2PMSG_126, GPU_ERR_USR_DP_LINK_TRAINING))
|
||||
dev_info(adev->dev, "socket: %d, aid: %d, usr dp link training failed\n",
|
||||
socket_id, aid_id);
|
||||
|
||||
if (REG_GET_FIELD(boot_error, MP0_SMN_C2PMSG_126, GPU_ERR_HBM_MEM_TEST))
|
||||
dev_info(adev->dev, "socket: %d, aid: %d, hbm: %d, hbm memory test failed\n",
|
||||
socket_id, aid_id, hbm_id);
|
||||
|
||||
if (REG_GET_FIELD(boot_error, MP0_SMN_C2PMSG_126, GPU_ERR_HBM_BIST_TEST))
|
||||
dev_info(adev->dev, "socket: %d, aid: %d, hbm: %d, hbm bist test failed\n",
|
||||
socket_id, aid_id, hbm_id);
|
||||
}
|
||||
|
||||
static int psp_v13_0_query_boot_status(struct psp_context *psp)
|
||||
{
|
||||
struct amdgpu_device *adev = psp->adev;
|
||||
int inst_mask = adev->aid_mask;
|
||||
uint32_t reg_data;
|
||||
uint32_t i;
|
||||
int ret = 0;
|
||||
|
||||
if (amdgpu_ip_version(adev, MP0_HWIP, 0) != IP_VERSION(13, 0, 6))
|
||||
return 0;
|
||||
|
||||
if (RREG32_SOC15(MP0, 0, regMP0_SMN_C2PMSG_59) < 0x00a10007)
|
||||
return 0;
|
||||
|
||||
for_each_inst(i, inst_mask) {
|
||||
reg_data = RREG32_SOC15(MP0, i, regMP0_SMN_C2PMSG_126);
|
||||
if (!REG_GET_FIELD(reg_data, MP0_SMN_C2PMSG_126, BOOT_STATUS)) {
|
||||
psp_v13_0_boot_error_reporting(adev, i, reg_data);
|
||||
ret = -EINVAL;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static const struct psp_funcs psp_v13_0_funcs = {
|
||||
.init_microcode = psp_v13_0_init_microcode,
|
||||
.wait_for_bootloader = psp_v13_0_wait_for_bootloader_steady_state,
|
||||
@ -781,6 +858,7 @@ static const struct psp_funcs psp_v13_0_funcs = {
|
||||
.update_spirom = psp_v13_0_update_spirom,
|
||||
.vbflash_stat = psp_v13_0_vbflash_status,
|
||||
.fatal_error_recovery_quirk = psp_v13_0_fatal_error_recovery_quirk,
|
||||
.query_boot_status = psp_v13_0_query_boot_status,
|
||||
};
|
||||
|
||||
void psp_v13_0_set_psp_funcs(struct psp_context *psp)
|
||||
|
@ -91,8 +91,7 @@ static void umc_v12_0_reset_error_count(struct amdgpu_device *adev)
|
||||
static bool umc_v12_0_is_uncorrectable_error(uint64_t mc_umc_status)
|
||||
{
|
||||
return ((REG_GET_FIELD(mc_umc_status, MCA_UMC_UMC0_MCUMC_STATUST0, Val) == 1) &&
|
||||
(REG_GET_FIELD(mc_umc_status, MCA_UMC_UMC0_MCUMC_STATUST0, Deferred) == 1 ||
|
||||
REG_GET_FIELD(mc_umc_status, MCA_UMC_UMC0_MCUMC_STATUST0, PCC) == 1 ||
|
||||
(REG_GET_FIELD(mc_umc_status, MCA_UMC_UMC0_MCUMC_STATUST0, PCC) == 1 ||
|
||||
REG_GET_FIELD(mc_umc_status, MCA_UMC_UMC0_MCUMC_STATUST0, UC) == 1 ||
|
||||
REG_GET_FIELD(mc_umc_status, MCA_UMC_UMC0_MCUMC_STATUST0, TCC) == 1));
|
||||
}
|
||||
|
@ -1404,6 +1404,66 @@ static int kfd_fill_gpu_cache_info_from_gfx_config(struct kfd_dev *kdev,
|
||||
return i;
|
||||
}
|
||||
|
||||
static int kfd_fill_gpu_cache_info_from_gfx_config_v2(struct kfd_dev *kdev,
|
||||
struct kfd_gpu_cache_info *pcache_info)
|
||||
{
|
||||
struct amdgpu_device *adev = kdev->adev;
|
||||
int i = 0;
|
||||
|
||||
/* TCP L1 Cache per CU */
|
||||
if (adev->gfx.config.gc_tcp_size_per_cu) {
|
||||
pcache_info[i].cache_size = adev->gfx.config.gc_tcp_size_per_cu;
|
||||
pcache_info[i].cache_level = 1;
|
||||
pcache_info[i].flags = (CRAT_CACHE_FLAGS_ENABLED |
|
||||
CRAT_CACHE_FLAGS_DATA_CACHE |
|
||||
CRAT_CACHE_FLAGS_SIMD_CACHE);
|
||||
pcache_info[i].num_cu_shared = 1;
|
||||
i++;
|
||||
}
|
||||
/* Scalar L1 Instruction Cache per SQC */
|
||||
if (adev->gfx.config.gc_l1_instruction_cache_size_per_sqc) {
|
||||
pcache_info[i].cache_size =
|
||||
adev->gfx.config.gc_l1_instruction_cache_size_per_sqc;
|
||||
pcache_info[i].cache_level = 1;
|
||||
pcache_info[i].flags = (CRAT_CACHE_FLAGS_ENABLED |
|
||||
CRAT_CACHE_FLAGS_INST_CACHE |
|
||||
CRAT_CACHE_FLAGS_SIMD_CACHE);
|
||||
pcache_info[i].num_cu_shared = adev->gfx.config.gc_num_cu_per_sqc;
|
||||
i++;
|
||||
}
|
||||
/* Scalar L1 Data Cache per SQC */
|
||||
if (adev->gfx.config.gc_l1_data_cache_size_per_sqc) {
|
||||
pcache_info[i].cache_size = adev->gfx.config.gc_l1_data_cache_size_per_sqc;
|
||||
pcache_info[i].cache_level = 1;
|
||||
pcache_info[i].flags = (CRAT_CACHE_FLAGS_ENABLED |
|
||||
CRAT_CACHE_FLAGS_DATA_CACHE |
|
||||
CRAT_CACHE_FLAGS_SIMD_CACHE);
|
||||
pcache_info[i].num_cu_shared = adev->gfx.config.gc_num_cu_per_sqc;
|
||||
i++;
|
||||
}
|
||||
/* L2 Data Cache per GPU (Total Tex Cache) */
|
||||
if (adev->gfx.config.gc_tcc_size) {
|
||||
pcache_info[i].cache_size = adev->gfx.config.gc_tcc_size;
|
||||
pcache_info[i].cache_level = 2;
|
||||
pcache_info[i].flags = (CRAT_CACHE_FLAGS_ENABLED |
|
||||
CRAT_CACHE_FLAGS_DATA_CACHE |
|
||||
CRAT_CACHE_FLAGS_SIMD_CACHE);
|
||||
pcache_info[i].num_cu_shared = adev->gfx.config.max_cu_per_sh;
|
||||
i++;
|
||||
}
|
||||
/* L3 Data Cache per GPU */
|
||||
if (adev->gmc.mall_size) {
|
||||
pcache_info[i].cache_size = adev->gmc.mall_size / 1024;
|
||||
pcache_info[i].cache_level = 3;
|
||||
pcache_info[i].flags = (CRAT_CACHE_FLAGS_ENABLED |
|
||||
CRAT_CACHE_FLAGS_DATA_CACHE |
|
||||
CRAT_CACHE_FLAGS_SIMD_CACHE);
|
||||
pcache_info[i].num_cu_shared = adev->gfx.config.max_cu_per_sh;
|
||||
i++;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
int kfd_get_gpu_cache_info(struct kfd_node *kdev, struct kfd_gpu_cache_info **pcache_info)
|
||||
{
|
||||
int num_of_cache_types = 0;
|
||||
@ -1461,10 +1521,14 @@ int kfd_get_gpu_cache_info(struct kfd_node *kdev, struct kfd_gpu_cache_info **pc
|
||||
num_of_cache_types = ARRAY_SIZE(vega20_cache_info);
|
||||
break;
|
||||
case IP_VERSION(9, 4, 2):
|
||||
case IP_VERSION(9, 4, 3):
|
||||
*pcache_info = aldebaran_cache_info;
|
||||
num_of_cache_types = ARRAY_SIZE(aldebaran_cache_info);
|
||||
break;
|
||||
case IP_VERSION(9, 4, 3):
|
||||
num_of_cache_types =
|
||||
kfd_fill_gpu_cache_info_from_gfx_config_v2(kdev->kfd,
|
||||
*pcache_info);
|
||||
break;
|
||||
case IP_VERSION(9, 1, 0):
|
||||
case IP_VERSION(9, 2, 2):
|
||||
*pcache_info = raven_cache_info;
|
||||
|
@ -1602,10 +1602,13 @@ static int fill_in_l2_l3_pcache(struct kfd_cache_properties **props_ext,
|
||||
unsigned int cu_sibling_map_mask;
|
||||
int first_active_cu;
|
||||
int i, j, k, xcc, start, end;
|
||||
int num_xcc = NUM_XCC(knode->xcc_mask);
|
||||
struct kfd_cache_properties *pcache = NULL;
|
||||
enum amdgpu_memory_partition mode;
|
||||
struct amdgpu_device *adev = knode->adev;
|
||||
|
||||
start = ffs(knode->xcc_mask) - 1;
|
||||
end = start + NUM_XCC(knode->xcc_mask);
|
||||
end = start + num_xcc;
|
||||
cu_sibling_map_mask = cu_info->bitmap[start][0][0];
|
||||
cu_sibling_map_mask &=
|
||||
((1 << pcache_info[cache_type].num_cu_shared) - 1);
|
||||
@ -1624,7 +1627,18 @@ static int fill_in_l2_l3_pcache(struct kfd_cache_properties **props_ext,
|
||||
pcache->processor_id_low = cu_processor_id
|
||||
+ (first_active_cu - 1);
|
||||
pcache->cache_level = pcache_info[cache_type].cache_level;
|
||||
pcache->cache_size = pcache_info[cache_type].cache_size;
|
||||
|
||||
if (KFD_GC_VERSION(knode) == IP_VERSION(9, 4, 3))
|
||||
mode = adev->gmc.gmc_funcs->query_mem_partition_mode(adev);
|
||||
else
|
||||
mode = UNKNOWN_MEMORY_PARTITION_MODE;
|
||||
|
||||
if (pcache->cache_level == 2)
|
||||
pcache->cache_size = pcache_info[cache_type].cache_size * num_xcc;
|
||||
else if (mode)
|
||||
pcache->cache_size = pcache_info[cache_type].cache_size / mode;
|
||||
else
|
||||
pcache->cache_size = pcache_info[cache_type].cache_size;
|
||||
|
||||
if (pcache_info[cache_type].flags & CRAT_CACHE_FLAGS_DATA_CACHE)
|
||||
pcache->cache_type |= HSA_CACHE_TYPE_DATA;
|
||||
|
@ -4348,7 +4348,6 @@ static bool full_update_required(struct dc *dc,
|
||||
srf_updates[i].in_transfer_func ||
|
||||
srf_updates[i].func_shaper ||
|
||||
srf_updates[i].lut3d_func ||
|
||||
srf_updates[i].blend_tf ||
|
||||
srf_updates[i].surface->force_full_update ||
|
||||
(srf_updates[i].flip_addr &&
|
||||
srf_updates[i].flip_addr->address.tmz_surface != srf_updates[i].surface->address.tmz_surface) ||
|
||||
|
@ -533,7 +533,7 @@ uint32_t dc_stream_get_vblank_counter(const struct dc_stream_state *stream)
|
||||
for (i = 0; i < MAX_PIPES; i++) {
|
||||
struct timing_generator *tg = res_ctx->pipe_ctx[i].stream_res.tg;
|
||||
|
||||
if (res_ctx->pipe_ctx[i].stream != stream)
|
||||
if (res_ctx->pipe_ctx[i].stream != stream || !tg)
|
||||
continue;
|
||||
|
||||
return tg->funcs->get_frame_count(tg);
|
||||
@ -592,7 +592,7 @@ bool dc_stream_get_scanoutpos(const struct dc_stream_state *stream,
|
||||
for (i = 0; i < MAX_PIPES; i++) {
|
||||
struct timing_generator *tg = res_ctx->pipe_ctx[i].stream_res.tg;
|
||||
|
||||
if (res_ctx->pipe_ctx[i].stream != stream)
|
||||
if (res_ctx->pipe_ctx[i].stream != stream || !tg)
|
||||
continue;
|
||||
|
||||
tg->funcs->get_scanoutpos(tg,
|
||||
|
@ -613,16 +613,19 @@ static void dpp3_program_blnd_pwl(
|
||||
REG_SET(CM_BLNDGAM_LUT_DATA, 0, CM_BLNDGAM_LUT_DATA, rgb[i].red_reg);
|
||||
REG_SET(CM_BLNDGAM_LUT_DATA, 0, CM_BLNDGAM_LUT_DATA, last_base_value_red);
|
||||
} else {
|
||||
REG_SET(CM_BLNDGAM_LUT_INDEX, 0, CM_BLNDGAM_LUT_INDEX, 0);
|
||||
REG_UPDATE(CM_BLNDGAM_LUT_CONTROL, CM_BLNDGAM_LUT_WRITE_COLOR_MASK, 4);
|
||||
for (i = 0 ; i < num; i++)
|
||||
REG_SET(CM_BLNDGAM_LUT_DATA, 0, CM_BLNDGAM_LUT_DATA, rgb[i].red_reg);
|
||||
REG_SET(CM_BLNDGAM_LUT_DATA, 0, CM_BLNDGAM_LUT_DATA, last_base_value_red);
|
||||
|
||||
REG_SET(CM_BLNDGAM_LUT_INDEX, 0, CM_BLNDGAM_LUT_INDEX, 0);
|
||||
REG_UPDATE(CM_BLNDGAM_LUT_CONTROL, CM_BLNDGAM_LUT_WRITE_COLOR_MASK, 2);
|
||||
for (i = 0 ; i < num; i++)
|
||||
REG_SET(CM_BLNDGAM_LUT_DATA, 0, CM_BLNDGAM_LUT_DATA, rgb[i].green_reg);
|
||||
REG_SET(CM_BLNDGAM_LUT_DATA, 0, CM_BLNDGAM_LUT_DATA, last_base_value_green);
|
||||
|
||||
REG_SET(CM_BLNDGAM_LUT_INDEX, 0, CM_BLNDGAM_LUT_INDEX, 0);
|
||||
REG_UPDATE(CM_BLNDGAM_LUT_CONTROL, CM_BLNDGAM_LUT_WRITE_COLOR_MASK, 1);
|
||||
for (i = 0 ; i < num; i++)
|
||||
REG_SET(CM_BLNDGAM_LUT_DATA, 0, CM_BLNDGAM_LUT_DATA, rgb[i].blue_reg);
|
||||
|
@ -316,7 +316,7 @@ bool hubp3_program_surface_flip_and_addr(
|
||||
return true;
|
||||
}
|
||||
|
||||
static void hubp3_program_tiling(
|
||||
void hubp3_program_tiling(
|
||||
struct dcn20_hubp *hubp2,
|
||||
const union dc_tiling_info *info,
|
||||
const enum surface_pixel_format pixel_format)
|
||||
|
@ -278,6 +278,11 @@ void hubp3_setup(
|
||||
struct _vcs_dpi_display_rq_regs_st *rq_regs,
|
||||
struct _vcs_dpi_display_pipe_dest_params_st *pipe_dest);
|
||||
|
||||
void hubp3_program_tiling(
|
||||
struct dcn20_hubp *hubp2,
|
||||
const union dc_tiling_info *info,
|
||||
const enum surface_pixel_format pixel_format);
|
||||
|
||||
void hubp3_dcc_control(struct hubp *hubp, bool enable,
|
||||
enum hubp_ind_block_size blk_size);
|
||||
|
||||
|
@ -237,16 +237,19 @@ void mpc32_program_post1dlut_pwl(
|
||||
REG_SET(MPCC_MCM_1DLUT_LUT_DATA[mpcc_id], 0, MPCC_MCM_1DLUT_LUT_DATA, rgb[i].red_reg);
|
||||
REG_SET(MPCC_MCM_1DLUT_LUT_DATA[mpcc_id], 0, MPCC_MCM_1DLUT_LUT_DATA, last_base_value_red);
|
||||
} else {
|
||||
REG_SET(MPCC_MCM_1DLUT_LUT_INDEX[mpcc_id], 0, MPCC_MCM_1DLUT_LUT_INDEX, 0);
|
||||
REG_UPDATE(MPCC_MCM_1DLUT_LUT_CONTROL[mpcc_id], MPCC_MCM_1DLUT_LUT_WRITE_COLOR_MASK, 4);
|
||||
for (i = 0 ; i < num; i++)
|
||||
REG_SET(MPCC_MCM_1DLUT_LUT_DATA[mpcc_id], 0, MPCC_MCM_1DLUT_LUT_DATA, rgb[i].red_reg);
|
||||
REG_SET(MPCC_MCM_1DLUT_LUT_DATA[mpcc_id], 0, MPCC_MCM_1DLUT_LUT_DATA, last_base_value_red);
|
||||
|
||||
REG_SET(MPCC_MCM_1DLUT_LUT_INDEX[mpcc_id], 0, MPCC_MCM_1DLUT_LUT_INDEX, 0);
|
||||
REG_UPDATE(MPCC_MCM_1DLUT_LUT_CONTROL[mpcc_id], MPCC_MCM_1DLUT_LUT_WRITE_COLOR_MASK, 2);
|
||||
for (i = 0 ; i < num; i++)
|
||||
REG_SET(MPCC_MCM_1DLUT_LUT_DATA[mpcc_id], 0, MPCC_MCM_1DLUT_LUT_DATA, rgb[i].green_reg);
|
||||
REG_SET(MPCC_MCM_1DLUT_LUT_DATA[mpcc_id], 0, MPCC_MCM_1DLUT_LUT_DATA, last_base_value_green);
|
||||
|
||||
REG_SET(MPCC_MCM_1DLUT_LUT_INDEX[mpcc_id], 0, MPCC_MCM_1DLUT_LUT_INDEX, 0);
|
||||
REG_UPDATE(MPCC_MCM_1DLUT_LUT_CONTROL[mpcc_id], MPCC_MCM_1DLUT_LUT_WRITE_COLOR_MASK, 1);
|
||||
for (i = 0 ; i < num; i++)
|
||||
REG_SET(MPCC_MCM_1DLUT_LUT_DATA[mpcc_id], 0, MPCC_MCM_1DLUT_LUT_DATA, rgb[i].blue_reg);
|
||||
|
@ -53,11 +53,146 @@ static void hubp35_init(struct hubp *hubp)
|
||||
|
||||
/*do nothing for now for dcn3.5 or later*/
|
||||
}
|
||||
|
||||
void hubp35_program_pixel_format(
|
||||
struct hubp *hubp,
|
||||
enum surface_pixel_format format)
|
||||
{
|
||||
struct dcn20_hubp *hubp2 = TO_DCN20_HUBP(hubp);
|
||||
uint32_t green_bar = 1;
|
||||
uint32_t red_bar = 3;
|
||||
uint32_t blue_bar = 2;
|
||||
|
||||
/* swap for ABGR format */
|
||||
if (format == SURFACE_PIXEL_FORMAT_GRPH_ABGR8888
|
||||
|| format == SURFACE_PIXEL_FORMAT_GRPH_ABGR2101010
|
||||
|| format == SURFACE_PIXEL_FORMAT_GRPH_ABGR2101010_XR_BIAS
|
||||
|| format == SURFACE_PIXEL_FORMAT_GRPH_ABGR16161616
|
||||
|| format == SURFACE_PIXEL_FORMAT_GRPH_ABGR16161616F) {
|
||||
red_bar = 2;
|
||||
blue_bar = 3;
|
||||
}
|
||||
|
||||
REG_UPDATE_3(HUBPRET_CONTROL,
|
||||
CROSSBAR_SRC_Y_G, green_bar,
|
||||
CROSSBAR_SRC_CB_B, blue_bar,
|
||||
CROSSBAR_SRC_CR_R, red_bar);
|
||||
|
||||
/* Mapping is same as ipp programming (cnvc) */
|
||||
|
||||
switch (format) {
|
||||
case SURFACE_PIXEL_FORMAT_GRPH_ARGB1555:
|
||||
REG_UPDATE(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 1);
|
||||
break;
|
||||
case SURFACE_PIXEL_FORMAT_GRPH_RGB565:
|
||||
REG_UPDATE(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 3);
|
||||
break;
|
||||
case SURFACE_PIXEL_FORMAT_GRPH_ARGB8888:
|
||||
case SURFACE_PIXEL_FORMAT_GRPH_ABGR8888:
|
||||
REG_UPDATE(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 8);
|
||||
break;
|
||||
case SURFACE_PIXEL_FORMAT_GRPH_ARGB2101010:
|
||||
case SURFACE_PIXEL_FORMAT_GRPH_ABGR2101010:
|
||||
case SURFACE_PIXEL_FORMAT_GRPH_ABGR2101010_XR_BIAS:
|
||||
REG_UPDATE(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 10);
|
||||
break;
|
||||
case SURFACE_PIXEL_FORMAT_GRPH_ARGB16161616:
|
||||
case SURFACE_PIXEL_FORMAT_GRPH_ABGR16161616: /* we use crossbar already */
|
||||
REG_UPDATE(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 26); /* ARGB16161616_UNORM */
|
||||
break;
|
||||
case SURFACE_PIXEL_FORMAT_GRPH_ARGB16161616F:
|
||||
case SURFACE_PIXEL_FORMAT_GRPH_ABGR16161616F:/*we use crossbar already*/
|
||||
REG_UPDATE(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 24);
|
||||
break;
|
||||
|
||||
case SURFACE_PIXEL_FORMAT_VIDEO_420_YCbCr:
|
||||
REG_UPDATE(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 65);
|
||||
break;
|
||||
case SURFACE_PIXEL_FORMAT_VIDEO_420_YCrCb:
|
||||
REG_UPDATE(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 64);
|
||||
break;
|
||||
case SURFACE_PIXEL_FORMAT_VIDEO_420_10bpc_YCbCr:
|
||||
REG_UPDATE(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 67);
|
||||
break;
|
||||
case SURFACE_PIXEL_FORMAT_VIDEO_420_10bpc_YCrCb:
|
||||
REG_UPDATE(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 66);
|
||||
break;
|
||||
case SURFACE_PIXEL_FORMAT_VIDEO_AYCrCb8888:
|
||||
REG_UPDATE(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 12);
|
||||
break;
|
||||
case SURFACE_PIXEL_FORMAT_GRPH_RGB111110_FIX:
|
||||
REG_UPDATE(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 112);
|
||||
break;
|
||||
case SURFACE_PIXEL_FORMAT_GRPH_BGR101111_FIX:
|
||||
REG_UPDATE(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 113);
|
||||
break;
|
||||
case SURFACE_PIXEL_FORMAT_VIDEO_ACrYCb2101010:
|
||||
REG_UPDATE(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 114);
|
||||
break;
|
||||
case SURFACE_PIXEL_FORMAT_GRPH_RGB111110_FLOAT:
|
||||
REG_UPDATE(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 118);
|
||||
break;
|
||||
case SURFACE_PIXEL_FORMAT_GRPH_BGR101111_FLOAT:
|
||||
REG_UPDATE(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 119);
|
||||
break;
|
||||
case SURFACE_PIXEL_FORMAT_GRPH_RGBE:
|
||||
REG_UPDATE_2(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 116,
|
||||
ALPHA_PLANE_EN, 0);
|
||||
break;
|
||||
case SURFACE_PIXEL_FORMAT_GRPH_RGBE_ALPHA:
|
||||
REG_UPDATE_2(DCSURF_SURFACE_CONFIG,
|
||||
SURFACE_PIXEL_FORMAT, 116,
|
||||
ALPHA_PLANE_EN, 1);
|
||||
break;
|
||||
default:
|
||||
BREAK_TO_DEBUGGER();
|
||||
break;
|
||||
}
|
||||
|
||||
/* don't see the need of program the xbar in DCN 1.0 */
|
||||
}
|
||||
|
||||
void hubp35_program_surface_config(
|
||||
struct hubp *hubp,
|
||||
enum surface_pixel_format format,
|
||||
union dc_tiling_info *tiling_info,
|
||||
struct plane_size *plane_size,
|
||||
enum dc_rotation_angle rotation,
|
||||
struct dc_plane_dcc_param *dcc,
|
||||
bool horizontal_mirror,
|
||||
unsigned int compat_level)
|
||||
{
|
||||
struct dcn20_hubp *hubp2 = TO_DCN20_HUBP(hubp);
|
||||
|
||||
hubp3_dcc_control_sienna_cichlid(hubp, dcc);
|
||||
hubp3_program_tiling(hubp2, tiling_info, format);
|
||||
hubp2_program_size(hubp, format, plane_size, dcc);
|
||||
hubp2_program_rotation(hubp, rotation, horizontal_mirror);
|
||||
hubp35_program_pixel_format(hubp, format);
|
||||
}
|
||||
|
||||
struct hubp_funcs dcn35_hubp_funcs = {
|
||||
.hubp_enable_tripleBuffer = hubp2_enable_triplebuffer,
|
||||
.hubp_is_triplebuffer_enabled = hubp2_is_triplebuffer_enabled,
|
||||
.hubp_program_surface_flip_and_addr = hubp3_program_surface_flip_and_addr,
|
||||
.hubp_program_surface_config = hubp3_program_surface_config,
|
||||
.hubp_program_surface_config = hubp35_program_surface_config,
|
||||
.hubp_is_flip_pending = hubp2_is_flip_pending,
|
||||
.hubp_setup = hubp3_setup,
|
||||
.hubp_setup_interdependent = hubp2_setup_interdependent,
|
||||
|
@ -58,4 +58,18 @@ bool hubp35_construct(
|
||||
|
||||
void hubp35_set_fgcg(struct hubp *hubp, bool enable);
|
||||
|
||||
void hubp35_program_pixel_format(
|
||||
struct hubp *hubp,
|
||||
enum surface_pixel_format format);
|
||||
|
||||
void hubp35_program_surface_config(
|
||||
struct hubp *hubp,
|
||||
enum surface_pixel_format format,
|
||||
union dc_tiling_info *tiling_info,
|
||||
struct plane_size *plane_size,
|
||||
enum dc_rotation_angle rotation,
|
||||
struct dc_plane_dcc_param *dcc,
|
||||
bool horizontal_mirror,
|
||||
unsigned int compat_level);
|
||||
|
||||
#endif /* __DC_HUBP_DCN35_H__ */
|
||||
|
@ -60,8 +60,12 @@ endif
|
||||
endif
|
||||
|
||||
ifneq ($(CONFIG_FRAME_WARN),0)
|
||||
ifeq ($(filter y,$(CONFIG_KASAN)$(CONFIG_KCSAN)),y)
|
||||
frame_warn_flag := -Wframe-larger-than=3072
|
||||
else
|
||||
frame_warn_flag := -Wframe-larger-than=2048
|
||||
endif
|
||||
endif
|
||||
|
||||
CFLAGS_$(AMDDALPATH)/dc/dml2/display_mode_core.o := $(dml2_ccflags) $(frame_warn_flag)
|
||||
CFLAGS_$(AMDDALPATH)/dc/dml2/display_mode_util.o := $(dml2_ccflags)
|
||||
|
@ -242,6 +242,34 @@
|
||||
//MP0_SMN_C2PMSG_103
|
||||
#define MP0_SMN_C2PMSG_103__CONTENT__SHIFT 0x0
|
||||
#define MP0_SMN_C2PMSG_103__CONTENT_MASK 0xFFFFFFFFL
|
||||
//MP0_SMN_C2PMSG_109
|
||||
#define MP0_SMN_C2PMSG_109__CONTENT__SHIFT 0x0
|
||||
#define MP0_SMN_C2PMSG_109__CONTENT_MASK 0xFFFFFFFFL
|
||||
//MP0_SMN_C2PMSG_126
|
||||
#define MP0_SMN_C2PMSG_126__GPU_ERR_MEM_TRAINING__SHIFT 0x0
|
||||
#define MP0_SMN_C2PMSG_126__GPU_ERR_FW_LOAD__SHIFT 0x1
|
||||
#define MP0_SMN_C2PMSG_126__GPU_ERR_WAFL_LINK_TRAINING__SHIFT 0x2
|
||||
#define MP0_SMN_C2PMSG_126__GPU_ERR_XGMI_LINK_TRAINING__SHIFT 0x3
|
||||
#define MP0_SMN_C2PMSG_126__GPU_ERR_USR_CP_LINK_TRAINING__SHIFT 0x4
|
||||
#define MP0_SMN_C2PMSG_126__GPU_ERR_USR_DP_LINK_TRAINING__SHIFT 0x5
|
||||
#define MP0_SMN_C2PMSG_126__GPU_ERR_HBM_MEM_TEST__SHIFT 0x6
|
||||
#define MP0_SMN_C2PMSG_126__GPU_ERR_HBM_BIST_TEST__SHIFT 0x7
|
||||
#define MP0_SMN_C2PMSG_126__SOCKET_ID__SHIFT 0x8
|
||||
#define MP0_SMN_C2PMSG_126__AID_ID__SHIFT 0xb
|
||||
#define MP0_SMN_C2PMSG_126__HBM_ID__SHIFT 0xd
|
||||
#define MP0_SMN_C2PMSG_126__BOOT_STATUS__SHIFT 0x1f
|
||||
#define MP0_SMN_C2PMSG_126__GPU_ERR_MEM_TRAINING_MASK 0x00000001L
|
||||
#define MP0_SMN_C2PMSG_126__GPU_ERR_FW_LOAD_MASK 0x00000002L
|
||||
#define MP0_SMN_C2PMSG_126__GPU_ERR_WAFL_LINK_TRAINING_MASK 0x00000004L
|
||||
#define MP0_SMN_C2PMSG_126__GPU_ERR_XGMI_LINK_TRAINING_MASK 0x00000008L
|
||||
#define MP0_SMN_C2PMSG_126__GPU_ERR_USR_CP_LINK_TRAINING_MASK 0x00000010L
|
||||
#define MP0_SMN_C2PMSG_126__GPU_ERR_USR_DP_LINK_TRAINING_MASK 0x00000020L
|
||||
#define MP0_SMN_C2PMSG_126__GPU_ERR_HBM_MEM_TEST_MASK 0x00000040L
|
||||
#define MP0_SMN_C2PMSG_126__GPU_ERR_HBM_BIST_TEST_MASK 0x00000080L
|
||||
#define MP0_SMN_C2PMSG_126__SOCKET_ID_MASK 0x00000700L
|
||||
#define MP0_SMN_C2PMSG_126__AID_ID_MASK 0x00001800L
|
||||
#define MP0_SMN_C2PMSG_126__HBM_ID_MASK 0x00002000L
|
||||
#define MP0_SMN_C2PMSG_126__BOOT_STATUS_MASK 0x80000000L
|
||||
//MP0_SMN_IH_CREDIT
|
||||
#define MP0_SMN_IH_CREDIT__CREDIT_VALUE__SHIFT 0x0
|
||||
#define MP0_SMN_IH_CREDIT__CLIENT_ID__SHIFT 0x10
|
||||
|
@ -1080,33 +1080,35 @@ struct gpu_metrics_v3_0 {
|
||||
uint16_t average_ipu_activity[8];
|
||||
/* time filtered per-core C0 residency % [0-100]*/
|
||||
uint16_t average_core_c0_activity[16];
|
||||
/* time filtered DRAM read bandwidth [GB/sec] */
|
||||
/* time filtered DRAM read bandwidth [MB/sec] */
|
||||
uint16_t average_dram_reads;
|
||||
/* time filtered DRAM write bandwidth [GB/sec] */
|
||||
/* time filtered DRAM write bandwidth [MB/sec] */
|
||||
uint16_t average_dram_writes;
|
||||
|
||||
/* Driver attached timestamp (in ns) */
|
||||
uint64_t system_clock_counter;
|
||||
|
||||
/* Power/Energy */
|
||||
/* average dGPU + APU power on A + A platform */
|
||||
/* time filtered power used for PPT/STAPM [APU+dGPU] [mW] */
|
||||
uint32_t average_socket_power;
|
||||
/* average IPU power [W] */
|
||||
/* time filtered IPU power [mW] */
|
||||
uint16_t average_ipu_power;
|
||||
/* average APU power [W] */
|
||||
/* time filtered APU power [mW] */
|
||||
uint32_t average_apu_power;
|
||||
/* average dGPU power [W] */
|
||||
/* time filtered GFX power [mW] */
|
||||
uint32_t average_gfx_power;
|
||||
/* time filtered dGPU power [mW] */
|
||||
uint32_t average_dgpu_power;
|
||||
/* sum of core power across all cores in the socket [W] */
|
||||
uint32_t average_core_power;
|
||||
/* calculated core power [W] */
|
||||
uint16_t core_power[16];
|
||||
/* maximum IRM defined STAPM power limit [W] */
|
||||
/* time filtered sum of core power across all cores in the socket [mW] */
|
||||
uint32_t average_all_core_power;
|
||||
/* calculated core power [mW] */
|
||||
uint16_t average_core_power[16];
|
||||
/* maximum IRM defined STAPM power limit [mW] */
|
||||
uint16_t stapm_power_limit;
|
||||
/* time filtered STAPM power limit [W] */
|
||||
/* time filtered STAPM power limit [mW] */
|
||||
uint16_t current_stapm_power_limit;
|
||||
|
||||
/* Average clocks */
|
||||
/* time filtered clocks [MHz] */
|
||||
uint16_t average_gfxclk_frequency;
|
||||
uint16_t average_socclk_frequency;
|
||||
uint16_t average_vpeclk_frequency;
|
||||
@ -1115,7 +1117,7 @@ struct gpu_metrics_v3_0 {
|
||||
uint16_t average_vclk_frequency;
|
||||
|
||||
/* Current clocks */
|
||||
/* target core frequency */
|
||||
/* target core frequency [MHz] */
|
||||
uint16_t current_coreclk[16];
|
||||
/* CCLK frequency limit enforced on classic cores [MHz] */
|
||||
uint16_t current_core_maxfreq;
|
||||
|
@ -3288,10 +3288,6 @@ static umode_t hwmon_attributes_visible(struct kobject *kobj,
|
||||
uint32_t gc_ver = amdgpu_ip_version(adev, GC_HWIP, 0);
|
||||
uint32_t tmp;
|
||||
|
||||
/* under multi-vf mode, the hwmon attributes are all not supported */
|
||||
if (amdgpu_sriov_vf(adev) && !amdgpu_sriov_is_pp_one_vf(adev))
|
||||
return 0;
|
||||
|
||||
/* under pp one vf mode manage of hwmon attributes is not supported */
|
||||
if (amdgpu_sriov_is_pp_one_vf(adev))
|
||||
effective_mode &= ~S_IWUSR;
|
||||
@ -4162,6 +4158,7 @@ err_out:
|
||||
|
||||
int amdgpu_pm_sysfs_init(struct amdgpu_device *adev)
|
||||
{
|
||||
enum amdgpu_sriov_vf_mode mode;
|
||||
uint32_t mask = 0;
|
||||
int ret;
|
||||
|
||||
@ -4173,17 +4170,21 @@ int amdgpu_pm_sysfs_init(struct amdgpu_device *adev)
|
||||
if (adev->pm.dpm_enabled == 0)
|
||||
return 0;
|
||||
|
||||
adev->pm.int_hwmon_dev = hwmon_device_register_with_groups(adev->dev,
|
||||
DRIVER_NAME, adev,
|
||||
hwmon_groups);
|
||||
if (IS_ERR(adev->pm.int_hwmon_dev)) {
|
||||
ret = PTR_ERR(adev->pm.int_hwmon_dev);
|
||||
dev_err(adev->dev,
|
||||
"Unable to register hwmon device: %d\n", ret);
|
||||
return ret;
|
||||
mode = amdgpu_virt_get_sriov_vf_mode(adev);
|
||||
|
||||
/* under multi-vf mode, the hwmon attributes are all not supported */
|
||||
if (mode != SRIOV_VF_MODE_MULTI_VF) {
|
||||
adev->pm.int_hwmon_dev = hwmon_device_register_with_groups(adev->dev,
|
||||
DRIVER_NAME, adev,
|
||||
hwmon_groups);
|
||||
if (IS_ERR(adev->pm.int_hwmon_dev)) {
|
||||
ret = PTR_ERR(adev->pm.int_hwmon_dev);
|
||||
dev_err(adev->dev, "Unable to register hwmon device: %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
switch (amdgpu_virt_get_sriov_vf_mode(adev)) {
|
||||
switch (mode) {
|
||||
case SRIOV_VF_MODE_ONE_VF:
|
||||
mask = ATTR_FLAG_ONEVF;
|
||||
break;
|
||||
|
@ -1022,6 +1022,9 @@ static int pp_get_power_limit(void *handle, uint32_t *limit,
|
||||
*limit /= 100;
|
||||
}
|
||||
break;
|
||||
case PP_PWR_LIMIT_MIN:
|
||||
*limit = 0;
|
||||
break;
|
||||
default:
|
||||
ret = -EOPNOTSUPP;
|
||||
break;
|
||||
|
@ -367,7 +367,7 @@ typedef struct _ATOM_Tonga_VCE_State_Record {
|
||||
typedef struct _ATOM_Tonga_VCE_State_Table {
|
||||
UCHAR ucRevId;
|
||||
UCHAR ucNumEntries;
|
||||
ATOM_Tonga_VCE_State_Record entries[1];
|
||||
ATOM_Tonga_VCE_State_Record entries[];
|
||||
} ATOM_Tonga_VCE_State_Table;
|
||||
|
||||
typedef struct _ATOM_Tonga_PowerTune_Table {
|
||||
@ -481,7 +481,7 @@ typedef struct _ATOM_Tonga_Hard_Limit_Record {
|
||||
typedef struct _ATOM_Tonga_Hard_Limit_Table {
|
||||
UCHAR ucRevId;
|
||||
UCHAR ucNumEntries;
|
||||
ATOM_Tonga_Hard_Limit_Record entries[1];
|
||||
ATOM_Tonga_Hard_Limit_Record entries[];
|
||||
} ATOM_Tonga_Hard_Limit_Table;
|
||||
|
||||
typedef struct _ATOM_Tonga_GPIO_Table {
|
||||
|
@ -129,7 +129,7 @@ typedef struct _ATOM_Vega10_State {
|
||||
typedef struct _ATOM_Vega10_State_Array {
|
||||
UCHAR ucRevId;
|
||||
UCHAR ucNumEntries; /* Number of entries. */
|
||||
ATOM_Vega10_State states[1]; /* Dynamically allocate entries. */
|
||||
ATOM_Vega10_State states[]; /* Dynamically allocate entries. */
|
||||
} ATOM_Vega10_State_Array;
|
||||
|
||||
typedef struct _ATOM_Vega10_CLK_Dependency_Record {
|
||||
@ -169,37 +169,37 @@ typedef struct _ATOM_Vega10_GFXCLK_Dependency_Table {
|
||||
typedef struct _ATOM_Vega10_MCLK_Dependency_Table {
|
||||
UCHAR ucRevId;
|
||||
UCHAR ucNumEntries; /* Number of entries. */
|
||||
ATOM_Vega10_MCLK_Dependency_Record entries[1]; /* Dynamically allocate entries. */
|
||||
ATOM_Vega10_MCLK_Dependency_Record entries[]; /* Dynamically allocate entries. */
|
||||
} ATOM_Vega10_MCLK_Dependency_Table;
|
||||
|
||||
typedef struct _ATOM_Vega10_SOCCLK_Dependency_Table {
|
||||
UCHAR ucRevId;
|
||||
UCHAR ucNumEntries; /* Number of entries. */
|
||||
ATOM_Vega10_CLK_Dependency_Record entries[1]; /* Dynamically allocate entries. */
|
||||
ATOM_Vega10_CLK_Dependency_Record entries[]; /* Dynamically allocate entries. */
|
||||
} ATOM_Vega10_SOCCLK_Dependency_Table;
|
||||
|
||||
typedef struct _ATOM_Vega10_DCEFCLK_Dependency_Table {
|
||||
UCHAR ucRevId;
|
||||
UCHAR ucNumEntries; /* Number of entries. */
|
||||
ATOM_Vega10_CLK_Dependency_Record entries[1]; /* Dynamically allocate entries. */
|
||||
ATOM_Vega10_CLK_Dependency_Record entries[]; /* Dynamically allocate entries. */
|
||||
} ATOM_Vega10_DCEFCLK_Dependency_Table;
|
||||
|
||||
typedef struct _ATOM_Vega10_PIXCLK_Dependency_Table {
|
||||
UCHAR ucRevId;
|
||||
UCHAR ucNumEntries; /* Number of entries. */
|
||||
ATOM_Vega10_CLK_Dependency_Record entries[1]; /* Dynamically allocate entries. */
|
||||
ATOM_Vega10_CLK_Dependency_Record entries[]; /* Dynamically allocate entries. */
|
||||
} ATOM_Vega10_PIXCLK_Dependency_Table;
|
||||
|
||||
typedef struct _ATOM_Vega10_DISPCLK_Dependency_Table {
|
||||
UCHAR ucRevId;
|
||||
UCHAR ucNumEntries; /* Number of entries.*/
|
||||
ATOM_Vega10_CLK_Dependency_Record entries[1]; /* Dynamically allocate entries. */
|
||||
ATOM_Vega10_CLK_Dependency_Record entries[]; /* Dynamically allocate entries. */
|
||||
} ATOM_Vega10_DISPCLK_Dependency_Table;
|
||||
|
||||
typedef struct _ATOM_Vega10_PHYCLK_Dependency_Table {
|
||||
UCHAR ucRevId;
|
||||
UCHAR ucNumEntries; /* Number of entries. */
|
||||
ATOM_Vega10_CLK_Dependency_Record entries[1]; /* Dynamically allocate entries. */
|
||||
ATOM_Vega10_CLK_Dependency_Record entries[]; /* Dynamically allocate entries. */
|
||||
} ATOM_Vega10_PHYCLK_Dependency_Table;
|
||||
|
||||
typedef struct _ATOM_Vega10_MM_Dependency_Record {
|
||||
@ -213,7 +213,7 @@ typedef struct _ATOM_Vega10_MM_Dependency_Record {
|
||||
typedef struct _ATOM_Vega10_MM_Dependency_Table {
|
||||
UCHAR ucRevId;
|
||||
UCHAR ucNumEntries; /* Number of entries */
|
||||
ATOM_Vega10_MM_Dependency_Record entries[1]; /* Dynamically allocate entries */
|
||||
ATOM_Vega10_MM_Dependency_Record entries[]; /* Dynamically allocate entries */
|
||||
} ATOM_Vega10_MM_Dependency_Table;
|
||||
|
||||
typedef struct _ATOM_Vega10_PCIE_Record {
|
||||
@ -225,7 +225,7 @@ typedef struct _ATOM_Vega10_PCIE_Record {
|
||||
typedef struct _ATOM_Vega10_PCIE_Table {
|
||||
UCHAR ucRevId;
|
||||
UCHAR ucNumEntries; /* Number of entries */
|
||||
ATOM_Vega10_PCIE_Record entries[1]; /* Dynamically allocate entries. */
|
||||
ATOM_Vega10_PCIE_Record entries[]; /* Dynamically allocate entries. */
|
||||
} ATOM_Vega10_PCIE_Table;
|
||||
|
||||
typedef struct _ATOM_Vega10_Voltage_Lookup_Record {
|
||||
@ -235,7 +235,7 @@ typedef struct _ATOM_Vega10_Voltage_Lookup_Record {
|
||||
typedef struct _ATOM_Vega10_Voltage_Lookup_Table {
|
||||
UCHAR ucRevId;
|
||||
UCHAR ucNumEntries; /* Number of entries */
|
||||
ATOM_Vega10_Voltage_Lookup_Record entries[1]; /* Dynamically allocate entries */
|
||||
ATOM_Vega10_Voltage_Lookup_Record entries[]; /* Dynamically allocate entries */
|
||||
} ATOM_Vega10_Voltage_Lookup_Table;
|
||||
|
||||
typedef struct _ATOM_Vega10_Fan_Table {
|
||||
@ -327,7 +327,7 @@ typedef struct _ATOM_Vega10_VCE_State_Record {
|
||||
typedef struct _ATOM_Vega10_VCE_State_Table {
|
||||
UCHAR ucRevId;
|
||||
UCHAR ucNumEntries;
|
||||
ATOM_Vega10_VCE_State_Record entries[1];
|
||||
ATOM_Vega10_VCE_State_Record entries[];
|
||||
} ATOM_Vega10_VCE_State_Table;
|
||||
|
||||
typedef struct _ATOM_Vega10_PowerTune_Table {
|
||||
@ -427,7 +427,7 @@ typedef struct _ATOM_Vega10_Hard_Limit_Record {
|
||||
typedef struct _ATOM_Vega10_Hard_Limit_Table {
|
||||
UCHAR ucRevId;
|
||||
UCHAR ucNumEntries;
|
||||
ATOM_Vega10_Hard_Limit_Record entries[1];
|
||||
ATOM_Vega10_Hard_Limit_Record entries[];
|
||||
} ATOM_Vega10_Hard_Limit_Table;
|
||||
|
||||
typedef struct _Vega10_PPTable_Generic_SubTable_Header {
|
||||
|
@ -733,7 +733,7 @@ static int smu_early_init(void *handle)
|
||||
smu->adev = adev;
|
||||
smu->pm_enabled = !!amdgpu_dpm;
|
||||
smu->is_apu = false;
|
||||
smu->smu_baco.state = SMU_BACO_STATE_EXIT;
|
||||
smu->smu_baco.state = SMU_BACO_STATE_NONE;
|
||||
smu->smu_baco.platform_support = false;
|
||||
smu->user_dpm_profile.fan_mode = -1;
|
||||
|
||||
@ -1742,10 +1742,31 @@ static int smu_smc_hw_cleanup(struct smu_context *smu)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int smu_reset_mp1_state(struct smu_context *smu)
|
||||
{
|
||||
struct amdgpu_device *adev = smu->adev;
|
||||
int ret = 0;
|
||||
|
||||
if ((!adev->in_runpm) && (!adev->in_suspend) &&
|
||||
(!amdgpu_in_reset(adev)))
|
||||
switch (amdgpu_ip_version(adev, MP1_HWIP, 0)) {
|
||||
case IP_VERSION(13, 0, 0):
|
||||
case IP_VERSION(13, 0, 7):
|
||||
case IP_VERSION(13, 0, 10):
|
||||
ret = smu_set_mp1_state(smu, PP_MP1_STATE_UNLOAD);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int smu_hw_fini(void *handle)
|
||||
{
|
||||
struct amdgpu_device *adev = (struct amdgpu_device *)handle;
|
||||
struct smu_context *smu = adev->powerplay.pp_handle;
|
||||
int ret;
|
||||
|
||||
if (amdgpu_sriov_vf(adev) && !amdgpu_sriov_is_pp_one_vf(adev))
|
||||
return 0;
|
||||
@ -1763,7 +1784,15 @@ static int smu_hw_fini(void *handle)
|
||||
|
||||
adev->pm.dpm_enabled = false;
|
||||
|
||||
return smu_smc_hw_cleanup(smu);
|
||||
ret = smu_smc_hw_cleanup(smu);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = smu_reset_mp1_state(smu);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void smu_late_fini(void *handle)
|
||||
|
@ -419,6 +419,7 @@ enum smu_reset_mode {
|
||||
enum smu_baco_state {
|
||||
SMU_BACO_STATE_ENTER = 0,
|
||||
SMU_BACO_STATE_EXIT,
|
||||
SMU_BACO_STATE_NONE,
|
||||
};
|
||||
|
||||
struct smu_baco_context {
|
||||
|
@ -150,97 +150,39 @@ typedef struct {
|
||||
} DpmClocks_t;
|
||||
|
||||
typedef struct {
|
||||
uint16_t CoreFrequency[16]; //Target core frequency [MHz]
|
||||
uint16_t CorePower[16]; //CAC calculated core power [W] [Q8.8]
|
||||
uint16_t CoreTemperature[16]; //TSEN measured core temperature [C] [Q8.8]
|
||||
uint16_t GfxTemperature; //TSEN measured GFX temperature [C] [Q8.8]
|
||||
uint16_t SocTemperature; //TSEN measured SOC temperature [C] [Q8.8]
|
||||
uint16_t StapmOpnLimit; //Maximum IRM defined STAPM power limit [W] [Q8.8]
|
||||
uint16_t StapmCurrentLimit; //Time filtered STAPM power limit [W] [Q8.8]
|
||||
uint16_t InfrastructureCpuMaxFreq; //CCLK frequency limit enforced on classic cores [MHz]
|
||||
uint16_t InfrastructureGfxMaxFreq; //GFXCLK frequency limit enforced on GFX [MHz]
|
||||
uint16_t SkinTemp; //Maximum skin temperature reported by APU and HS2 chassis sensors [C] [Q8.8]
|
||||
uint16_t AverageGfxclkFrequency; //Time filtered target GFXCLK frequency [MHz]
|
||||
uint16_t AverageFclkFrequency; //Time filtered target FCLK frequency [MHz]
|
||||
uint16_t AverageGfxActivity; //Time filtered GFX busy % [0-100] [Q8.8]
|
||||
uint16_t AverageSocclkFrequency; //Time filtered target SOCCLK frequency [MHz]
|
||||
uint16_t AverageVclkFrequency; //Time filtered target VCLK frequency [MHz]
|
||||
uint16_t AverageVcnActivity; //Time filtered VCN busy % [0-100] [Q8.8]
|
||||
uint16_t AverageVpeclkFrequency; //Time filtered target VPECLK frequency [MHz]
|
||||
uint16_t AverageIpuclkFrequency; //Time filtered target IPUCLK frequency [MHz]
|
||||
uint16_t AverageIpuBusy[8]; //Time filtered IPU per-column busy % [0-100] [Q8.8]
|
||||
uint16_t AverageDRAMReads; //Time filtered DRAM read bandwidth [GB/sec] [Q8.8]
|
||||
uint16_t AverageDRAMWrites; //Time filtered DRAM write bandwidth [GB/sec] [Q8.8]
|
||||
uint16_t AverageCoreC0Residency[16]; //Time filtered per-core C0 residency % [0-100] [Q8.8]
|
||||
uint16_t IpuPower; //Time filtered IPU power [W] [Q8.8]
|
||||
uint32_t ApuPower; //Time filtered APU power [W] [Q24.8]
|
||||
uint32_t dGpuPower; //Time filtered dGPU power [W] [Q24.8]
|
||||
uint32_t AverageSocketPower; //Time filtered power used for PPT/STAPM [APU+dGPU] [W] [Q24.8]
|
||||
uint32_t AverageCorePower; //Time filtered sum of core power across all cores in the socket [W] [Q24.8]
|
||||
uint32_t FilterAlphaValue; //Metrics table alpha filter time constant [us]
|
||||
uint32_t MetricsCounter; //Counter that is incremented on every metrics table update [PM_TIMER cycles]
|
||||
uint16_t CoreFrequency[16]; //Target core frequency [MHz]
|
||||
uint16_t CorePower[16]; //CAC calculated core power [mW]
|
||||
uint16_t CoreTemperature[16]; //TSEN measured core temperature [centi-C]
|
||||
uint16_t GfxTemperature; //TSEN measured GFX temperature [centi-C]
|
||||
uint16_t SocTemperature; //TSEN measured SOC temperature [centi-C]
|
||||
uint16_t StapmOpnLimit; //Maximum IRM defined STAPM power limit [mW]
|
||||
uint16_t StapmCurrentLimit; //Time filtered STAPM power limit [mW]
|
||||
uint16_t InfrastructureCpuMaxFreq; //CCLK frequency limit enforced on classic cores [MHz]
|
||||
uint16_t InfrastructureGfxMaxFreq; //GFXCLK frequency limit enforced on GFX [MHz]
|
||||
uint16_t SkinTemp; //Maximum skin temperature reported by APU and HS2 chassis sensors [centi-C]
|
||||
uint16_t GfxclkFrequency; //Time filtered target GFXCLK frequency [MHz]
|
||||
uint16_t FclkFrequency; //Time filtered target FCLK frequency [MHz]
|
||||
uint16_t GfxActivity; //Time filtered GFX busy % [0-100]
|
||||
uint16_t SocclkFrequency; //Time filtered target SOCCLK frequency [MHz]
|
||||
uint16_t VclkFrequency; //Time filtered target VCLK frequency [MHz]
|
||||
uint16_t VcnActivity; //Time filtered VCN busy % [0-100]
|
||||
uint16_t VpeclkFrequency; //Time filtered target VPECLK frequency [MHz]
|
||||
uint16_t IpuclkFrequency; //Time filtered target IPUCLK frequency [MHz]
|
||||
uint16_t IpuBusy[8]; //Time filtered IPU per-column busy % [0-100]
|
||||
uint16_t DRAMReads; //Time filtered DRAM read bandwidth [MB/sec]
|
||||
uint16_t DRAMWrites; //Time filtered DRAM write bandwidth [MB/sec]
|
||||
uint16_t CoreC0Residency[16]; //Time filtered per-core C0 residency % [0-100]
|
||||
uint16_t IpuPower; //Time filtered IPU power [mW]
|
||||
uint32_t ApuPower; //Time filtered APU power [mW]
|
||||
uint32_t GfxPower; //Time filtered GFX power [mW]
|
||||
uint32_t dGpuPower; //Time filtered dGPU power [mW]
|
||||
uint32_t SocketPower; //Time filtered power used for PPT/STAPM [APU+dGPU] [mW]
|
||||
uint32_t AllCorePower; //Time filtered sum of core power across all cores in the socket [mW]
|
||||
uint32_t FilterAlphaValue; //Metrics table alpha filter time constant [us]
|
||||
uint32_t MetricsCounter; //Counter that is incremented on every metrics table update [PM_TIMER cycles]
|
||||
uint32_t spare[16];
|
||||
} SmuMetrics_t;
|
||||
|
||||
typedef struct {
|
||||
uint16_t GfxclkFrequency; //[MHz]
|
||||
uint16_t SocclkFrequency; //[MHz]
|
||||
uint16_t VclkFrequency; //[MHz]
|
||||
uint16_t DclkFrequency; //[MHz]
|
||||
uint16_t MemclkFrequency; //[MHz]
|
||||
uint16_t spare;
|
||||
uint16_t UvdActivity; //[centi]
|
||||
uint16_t GfxActivity; //[centi]
|
||||
|
||||
uint16_t Voltage[2]; //[mV] indices: VDDCR_VDD, VDDCR_SOC
|
||||
uint16_t Current[2]; //[mA] indices: VDDCR_VDD, VDDCR_SOC
|
||||
uint16_t Power[2]; //[mW] indices: VDDCR_VDD, VDDCR_SOC
|
||||
|
||||
uint16_t CoreFrequency[8]; //[MHz]
|
||||
uint16_t CorePower[8]; //[mW]
|
||||
uint16_t CoreTemperature[8]; //[centi-Celsius]
|
||||
uint16_t L3Frequency[2]; //[MHz]
|
||||
uint16_t L3Temperature[2]; //[centi-Celsius]
|
||||
|
||||
uint16_t spare2[24];
|
||||
|
||||
uint16_t GfxTemperature; //[centi-Celsius]
|
||||
uint16_t SocTemperature; //[centi-Celsius]
|
||||
uint16_t ThrottlerStatus;
|
||||
|
||||
uint16_t CurrentSocketPower; //[mW]
|
||||
uint16_t StapmOpnLimit; //[W]
|
||||
uint16_t StapmCurrentLimit; //[W]
|
||||
uint32_t ApuPower; //[mW]
|
||||
uint32_t dGpuPower; //[mW]
|
||||
|
||||
uint16_t VddTdcValue; //[mA]
|
||||
uint16_t SocTdcValue; //[mA]
|
||||
uint16_t VddEdcValue; //[mA]
|
||||
uint16_t SocEdcValue; //[mA]
|
||||
|
||||
uint16_t InfrastructureCpuMaxFreq; //[MHz]
|
||||
uint16_t InfrastructureGfxMaxFreq; //[MHz]
|
||||
|
||||
uint16_t SkinTemp;
|
||||
uint16_t DeviceState;
|
||||
uint16_t CurTemp; //[centi-Celsius]
|
||||
uint16_t FilterAlphaValue; //[m]
|
||||
|
||||
uint16_t AverageGfxclkFrequency;
|
||||
uint16_t AverageFclkFrequency;
|
||||
uint16_t AverageGfxActivity;
|
||||
uint16_t AverageSocclkFrequency;
|
||||
uint16_t AverageVclkFrequency;
|
||||
uint16_t AverageVcnActivity;
|
||||
uint16_t AverageDRAMReads; //Filtered DF Bandwidth::DRAM Reads
|
||||
uint16_t AverageDRAMWrites; //Filtered DF Bandwidth::DRAM Writes
|
||||
uint16_t AverageSocketPower; //Filtered value of CurrentSocketPower
|
||||
uint16_t AverageCorePower[2]; //Filtered of [sum of CorePower[8] per ccx])
|
||||
uint16_t AverageCoreC0Residency[16]; //Filtered of [average C0 residency % per core]
|
||||
uint16_t spare1;
|
||||
uint32_t MetricsCounter; //Counts the # of metrics table parameter reads per update to the metrics table, i.e. if the metrics table update happens every 1 second, this value could be up to 1000 if the smu collected metrics data every cycle, or as low as 0 if the smu was asleep the whole time. Reset to 0 after writing.
|
||||
} SmuMetrics_legacy_t;
|
||||
|
||||
//ISP tile definitions
|
||||
typedef enum {
|
||||
TILE_XTILE = 0, //ONO0
|
||||
|
@ -299,5 +299,7 @@ int smu_v13_0_update_pcie_parameters(struct smu_context *smu,
|
||||
uint8_t pcie_gen_cap,
|
||||
uint8_t pcie_width_cap);
|
||||
|
||||
int smu_v13_0_disable_pmfw_state(struct smu_context *smu);
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
@ -234,24 +234,15 @@ static int vangogh_tables_init(struct smu_context *smu)
|
||||
PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM);
|
||||
SMU_TABLE_INIT(tables, SMU_TABLE_ACTIVITY_MONITOR_COEFF, sizeof(DpmActivityMonitorCoeffExt_t),
|
||||
PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM);
|
||||
SMU_TABLE_INIT(tables, SMU_TABLE_SMU_METRICS, max(sizeof(SmuMetrics_t), sizeof(SmuMetrics_legacy_t)),
|
||||
PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM);
|
||||
|
||||
if (smu->smc_fw_if_version < 0x3) {
|
||||
SMU_TABLE_INIT(tables, SMU_TABLE_SMU_METRICS, sizeof(SmuMetrics_legacy_t),
|
||||
PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM);
|
||||
smu_table->metrics_table = kzalloc(sizeof(SmuMetrics_legacy_t), GFP_KERNEL);
|
||||
} else {
|
||||
SMU_TABLE_INIT(tables, SMU_TABLE_SMU_METRICS, sizeof(SmuMetrics_t),
|
||||
PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM);
|
||||
smu_table->metrics_table = kzalloc(sizeof(SmuMetrics_t), GFP_KERNEL);
|
||||
}
|
||||
smu_table->metrics_table = kzalloc(max(sizeof(SmuMetrics_t), sizeof(SmuMetrics_legacy_t)), GFP_KERNEL);
|
||||
if (!smu_table->metrics_table)
|
||||
goto err0_out;
|
||||
smu_table->metrics_time = 0;
|
||||
|
||||
if (smu->smc_fw_version >= 0x043F3E00)
|
||||
smu_table->gpu_metrics_table_size = sizeof(struct gpu_metrics_v2_3);
|
||||
else
|
||||
smu_table->gpu_metrics_table_size = sizeof(struct gpu_metrics_v2_2);
|
||||
smu_table->gpu_metrics_table_size = max(sizeof(struct gpu_metrics_v2_3), sizeof(struct gpu_metrics_v2_2));
|
||||
smu_table->gpu_metrics_table = kzalloc(smu_table->gpu_metrics_table_size, GFP_KERNEL);
|
||||
if (!smu_table->gpu_metrics_table)
|
||||
goto err1_out;
|
||||
|
@ -2477,3 +2477,16 @@ int smu_v13_0_update_pcie_parameters(struct smu_context *smu,
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int smu_v13_0_disable_pmfw_state(struct smu_context *smu)
|
||||
{
|
||||
int ret;
|
||||
struct amdgpu_device *adev = smu->adev;
|
||||
|
||||
WREG32_PCIE(MP1_Public | (smnMP1_FIRMWARE_FLAGS & 0xffffffff), 0);
|
||||
|
||||
ret = RREG32_PCIE(MP1_Public |
|
||||
(smnMP1_FIRMWARE_FLAGS & 0xffffffff));
|
||||
|
||||
return ret == 0 ? 0 : -EINVAL;
|
||||
}
|
||||
|
@ -354,12 +354,12 @@ static int smu_v13_0_0_check_powerplay_table(struct smu_context *smu)
|
||||
if (powerplay_table->platform_caps & SMU_13_0_0_PP_PLATFORM_CAP_HARDWAREDC)
|
||||
smu->dc_controlled_by_gpio = true;
|
||||
|
||||
if (powerplay_table->platform_caps & SMU_13_0_0_PP_PLATFORM_CAP_BACO ||
|
||||
powerplay_table->platform_caps & SMU_13_0_0_PP_PLATFORM_CAP_MACO)
|
||||
if (powerplay_table->platform_caps & SMU_13_0_0_PP_PLATFORM_CAP_BACO) {
|
||||
smu_baco->platform_support = true;
|
||||
|
||||
if (powerplay_table->platform_caps & SMU_13_0_0_PP_PLATFORM_CAP_MACO)
|
||||
smu_baco->maco_support = true;
|
||||
if (powerplay_table->platform_caps & SMU_13_0_0_PP_PLATFORM_CAP_MACO)
|
||||
smu_baco->maco_support = true;
|
||||
}
|
||||
|
||||
if (!overdrive_lowerlimits->FeatureCtrlMask ||
|
||||
!overdrive_upperlimits->FeatureCtrlMask)
|
||||
@ -2530,38 +2530,10 @@ static int smu_v13_0_0_set_power_profile_mode(struct smu_context *smu,
|
||||
}
|
||||
}
|
||||
|
||||
if (smu->power_profile_mode == PP_SMC_POWER_PROFILE_COMPUTE &&
|
||||
(((smu->adev->pdev->device == 0x744C) && (smu->adev->pdev->revision == 0xC8)) ||
|
||||
((smu->adev->pdev->device == 0x744C) && (smu->adev->pdev->revision == 0xCC)))) {
|
||||
ret = smu_cmn_update_table(smu,
|
||||
SMU_TABLE_ACTIVITY_MONITOR_COEFF,
|
||||
WORKLOAD_PPLIB_COMPUTE_BIT,
|
||||
(void *)(&activity_monitor_external),
|
||||
false);
|
||||
if (ret) {
|
||||
dev_err(smu->adev->dev, "[%s] Failed to get activity monitor!", __func__);
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = smu_cmn_update_table(smu,
|
||||
SMU_TABLE_ACTIVITY_MONITOR_COEFF,
|
||||
WORKLOAD_PPLIB_CUSTOM_BIT,
|
||||
(void *)(&activity_monitor_external),
|
||||
true);
|
||||
if (ret) {
|
||||
dev_err(smu->adev->dev, "[%s] Failed to set activity monitor!", __func__);
|
||||
return ret;
|
||||
}
|
||||
|
||||
workload_type = smu_cmn_to_asic_specific_index(smu,
|
||||
CMN2ASIC_MAPPING_WORKLOAD,
|
||||
PP_SMC_POWER_PROFILE_CUSTOM);
|
||||
} else {
|
||||
/* conv PP_SMC_POWER_PROFILE* to WORKLOAD_PPLIB_*_BIT */
|
||||
workload_type = smu_cmn_to_asic_specific_index(smu,
|
||||
/* conv PP_SMC_POWER_PROFILE* to WORKLOAD_PPLIB_*_BIT */
|
||||
workload_type = smu_cmn_to_asic_specific_index(smu,
|
||||
CMN2ASIC_MAPPING_WORKLOAD,
|
||||
smu->power_profile_mode);
|
||||
}
|
||||
|
||||
if (workload_type < 0)
|
||||
return -EINVAL;
|
||||
@ -2602,14 +2574,20 @@ static int smu_v13_0_0_baco_enter(struct smu_context *smu)
|
||||
static int smu_v13_0_0_baco_exit(struct smu_context *smu)
|
||||
{
|
||||
struct amdgpu_device *adev = smu->adev;
|
||||
int ret;
|
||||
|
||||
if (adev->in_runpm && smu_cmn_is_audio_func_enabled(adev)) {
|
||||
/* Wait for PMFW handling for the Dstate change */
|
||||
usleep_range(10000, 11000);
|
||||
return smu_v13_0_baco_set_armd3_sequence(smu, BACO_SEQ_ULPS);
|
||||
ret = smu_v13_0_baco_set_armd3_sequence(smu, BACO_SEQ_ULPS);
|
||||
} else {
|
||||
return smu_v13_0_baco_exit(smu);
|
||||
ret = smu_v13_0_baco_exit(smu);
|
||||
}
|
||||
|
||||
if (!ret)
|
||||
adev->gfx.is_poweron = false;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static bool smu_v13_0_0_is_mode1_reset_supported(struct smu_context *smu)
|
||||
@ -2794,7 +2772,13 @@ static int smu_v13_0_0_set_mp1_state(struct smu_context *smu,
|
||||
|
||||
switch (mp1_state) {
|
||||
case PP_MP1_STATE_UNLOAD:
|
||||
ret = smu_cmn_set_mp1_state(smu, mp1_state);
|
||||
ret = smu_cmn_send_smc_msg_with_param(smu,
|
||||
SMU_MSG_PrepareMp1ForUnload,
|
||||
0x55, NULL);
|
||||
|
||||
if (!ret && smu->smu_baco.state == SMU_BACO_STATE_EXIT)
|
||||
ret = smu_v13_0_disable_pmfw_state(smu);
|
||||
|
||||
break;
|
||||
default:
|
||||
/* Ignore others */
|
||||
|
@ -270,7 +270,7 @@ static int smu_v13_0_6_init_microcode(struct smu_context *smu)
|
||||
struct amdgpu_device *adev = smu->adev;
|
||||
uint32_t p2s_table_id = P2S_TABLE_ID_A;
|
||||
int ret = 0, i, p2stable_count;
|
||||
char ucode_prefix[30];
|
||||
char ucode_prefix[15];
|
||||
char fw_name[30];
|
||||
|
||||
/* No need to load P2S tables in IOV mode */
|
||||
|
@ -346,12 +346,13 @@ static int smu_v13_0_7_check_powerplay_table(struct smu_context *smu)
|
||||
if (powerplay_table->platform_caps & SMU_13_0_7_PP_PLATFORM_CAP_HARDWAREDC)
|
||||
smu->dc_controlled_by_gpio = true;
|
||||
|
||||
if (powerplay_table->platform_caps & SMU_13_0_7_PP_PLATFORM_CAP_BACO ||
|
||||
powerplay_table->platform_caps & SMU_13_0_7_PP_PLATFORM_CAP_MACO)
|
||||
if (powerplay_table->platform_caps & SMU_13_0_7_PP_PLATFORM_CAP_BACO) {
|
||||
smu_baco->platform_support = true;
|
||||
|
||||
if (smu_baco->platform_support && (BoardTable->HsrEnabled || BoardTable->VddqOffEnabled))
|
||||
smu_baco->maco_support = true;
|
||||
if ((powerplay_table->platform_caps & SMU_13_0_7_PP_PLATFORM_CAP_MACO)
|
||||
&& (BoardTable->HsrEnabled || BoardTable->VddqOffEnabled))
|
||||
smu_baco->maco_support = true;
|
||||
}
|
||||
|
||||
if (!overdrive_lowerlimits->FeatureCtrlMask ||
|
||||
!overdrive_upperlimits->FeatureCtrlMask)
|
||||
@ -2498,7 +2499,13 @@ static int smu_v13_0_7_set_mp1_state(struct smu_context *smu,
|
||||
|
||||
switch (mp1_state) {
|
||||
case PP_MP1_STATE_UNLOAD:
|
||||
ret = smu_cmn_set_mp1_state(smu, mp1_state);
|
||||
ret = smu_cmn_send_smc_msg_with_param(smu,
|
||||
SMU_MSG_PrepareMp1ForUnload,
|
||||
0x55, NULL);
|
||||
|
||||
if (!ret && smu->smu_baco.state == SMU_BACO_STATE_EXIT)
|
||||
ret = smu_v13_0_disable_pmfw_state(smu);
|
||||
|
||||
break;
|
||||
default:
|
||||
/* Ignore others */
|
||||
@ -2524,14 +2531,20 @@ static int smu_v13_0_7_baco_enter(struct smu_context *smu)
|
||||
static int smu_v13_0_7_baco_exit(struct smu_context *smu)
|
||||
{
|
||||
struct amdgpu_device *adev = smu->adev;
|
||||
int ret;
|
||||
|
||||
if (adev->in_runpm && smu_cmn_is_audio_func_enabled(adev)) {
|
||||
/* Wait for PMFW handling for the Dstate change */
|
||||
usleep_range(10000, 11000);
|
||||
return smu_v13_0_baco_set_armd3_sequence(smu, BACO_SEQ_ULPS);
|
||||
ret = smu_v13_0_baco_set_armd3_sequence(smu, BACO_SEQ_ULPS);
|
||||
} else {
|
||||
return smu_v13_0_baco_exit(smu);
|
||||
ret = smu_v13_0_baco_exit(smu);
|
||||
}
|
||||
|
||||
if (!ret)
|
||||
adev->gfx.is_poweron = false;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static bool smu_v13_0_7_is_mode1_reset_supported(struct smu_context *smu)
|
||||
|
@ -57,7 +57,7 @@ int smu_v14_0_init_microcode(struct smu_context *smu)
|
||||
{
|
||||
struct amdgpu_device *adev = smu->adev;
|
||||
char fw_name[30];
|
||||
char ucode_prefix[30];
|
||||
char ucode_prefix[15];
|
||||
int err = 0;
|
||||
const struct smc_firmware_header_v1_0 *hdr;
|
||||
const struct common_firmware_header *header;
|
||||
@ -229,6 +229,8 @@ int smu_v14_0_check_fw_version(struct smu_context *smu)
|
||||
smu->smc_driver_if_version = SMU14_DRIVER_IF_VERSION_SMU_V14_0_2;
|
||||
break;
|
||||
case IP_VERSION(14, 0, 0):
|
||||
if ((smu->smc_fw_version < 0x5d3a00))
|
||||
dev_warn(smu->adev->dev, "The PMFW version(%x) is behind in this BIOS!\n", smu->smc_fw_version);
|
||||
smu->smc_driver_if_version = SMU14_DRIVER_IF_VERSION_SMU_V14_0_0;
|
||||
break;
|
||||
default:
|
||||
|
@ -156,15 +156,10 @@ static int smu_v14_0_0_init_smc_tables(struct smu_context *smu)
|
||||
PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM);
|
||||
SMU_TABLE_INIT(tables, SMU_TABLE_DPMCLOCKS, sizeof(DpmClocks_t),
|
||||
PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM);
|
||||
if (smu->smc_fw_version > 0x5d3500) {
|
||||
SMU_TABLE_INIT(tables, SMU_TABLE_SMU_METRICS, sizeof(SmuMetrics_t),
|
||||
PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM);
|
||||
smu_table->metrics_table = kzalloc(sizeof(SmuMetrics_t), GFP_KERNEL);
|
||||
} else {
|
||||
SMU_TABLE_INIT(tables, SMU_TABLE_SMU_METRICS, sizeof(SmuMetrics_legacy_t),
|
||||
PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM);
|
||||
smu_table->metrics_table = kzalloc(sizeof(SmuMetrics_legacy_t), GFP_KERNEL);
|
||||
}
|
||||
SMU_TABLE_INIT(tables, SMU_TABLE_SMU_METRICS, sizeof(SmuMetrics_t),
|
||||
PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM);
|
||||
|
||||
smu_table->metrics_table = kzalloc(sizeof(SmuMetrics_t), GFP_KERNEL);
|
||||
if (!smu_table->metrics_table)
|
||||
goto err0_out;
|
||||
smu_table->metrics_time = 0;
|
||||
@ -177,10 +172,7 @@ static int smu_v14_0_0_init_smc_tables(struct smu_context *smu)
|
||||
if (!smu_table->watermarks_table)
|
||||
goto err2_out;
|
||||
|
||||
if (smu->smc_fw_version > 0x5d3500)
|
||||
smu_table->gpu_metrics_table_size = sizeof(struct gpu_metrics_v3_0);
|
||||
else
|
||||
smu_table->gpu_metrics_table_size = sizeof(struct gpu_metrics_v2_1);
|
||||
smu_table->gpu_metrics_table_size = sizeof(struct gpu_metrics_v3_0);
|
||||
smu_table->gpu_metrics_table = kzalloc(smu_table->gpu_metrics_table_size, GFP_KERNEL);
|
||||
if (!smu_table->gpu_metrics_table)
|
||||
goto err3_out;
|
||||
@ -242,13 +234,13 @@ static int smu_v14_0_0_get_smu_metrics_data(struct smu_context *smu,
|
||||
|
||||
switch (member) {
|
||||
case METRICS_AVERAGE_GFXCLK:
|
||||
*value = metrics->AverageGfxclkFrequency;
|
||||
*value = metrics->GfxclkFrequency;
|
||||
break;
|
||||
case METRICS_AVERAGE_SOCCLK:
|
||||
*value = metrics->AverageSocclkFrequency;
|
||||
*value = metrics->SocclkFrequency;
|
||||
break;
|
||||
case METRICS_AVERAGE_VCLK:
|
||||
*value = metrics->AverageVclkFrequency;
|
||||
*value = metrics->VclkFrequency;
|
||||
break;
|
||||
case METRICS_AVERAGE_DCLK:
|
||||
*value = 0;
|
||||
@ -257,25 +249,25 @@ static int smu_v14_0_0_get_smu_metrics_data(struct smu_context *smu,
|
||||
*value = 0;
|
||||
break;
|
||||
case METRICS_AVERAGE_FCLK:
|
||||
*value = metrics->AverageFclkFrequency;
|
||||
*value = metrics->FclkFrequency;
|
||||
break;
|
||||
case METRICS_AVERAGE_GFXACTIVITY:
|
||||
*value = metrics->AverageGfxActivity >> 8;
|
||||
*value = metrics->GfxActivity / 100;
|
||||
break;
|
||||
case METRICS_AVERAGE_VCNACTIVITY:
|
||||
*value = metrics->AverageVcnActivity >> 8;
|
||||
*value = metrics->VcnActivity / 100;
|
||||
break;
|
||||
case METRICS_AVERAGE_SOCKETPOWER:
|
||||
case METRICS_CURR_SOCKETPOWER:
|
||||
*value = (metrics->AverageSocketPower & 0xff00) +
|
||||
((metrics->AverageSocketPower & 0xff) * 100 >> 8);
|
||||
*value = (metrics->SocketPower / 1000 << 8) +
|
||||
(metrics->SocketPower % 1000 / 10);
|
||||
break;
|
||||
case METRICS_TEMPERATURE_EDGE:
|
||||
*value = (metrics->GfxTemperature >> 8) *
|
||||
*value = metrics->GfxTemperature / 100 *
|
||||
SMU_TEMPERATURE_UNITS_PER_CENTIGRADES;
|
||||
break;
|
||||
case METRICS_TEMPERATURE_HOTSPOT:
|
||||
*value = (metrics->SocTemperature >> 8) *
|
||||
*value = metrics->SocTemperature / 100 *
|
||||
SMU_TEMPERATURE_UNITS_PER_CENTIGRADES;
|
||||
break;
|
||||
case METRICS_THROTTLER_STATUS:
|
||||
@ -317,107 +309,6 @@ static int smu_v14_0_0_get_smu_metrics_data(struct smu_context *smu,
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int smu_v14_0_0_legacy_get_smu_metrics_data(struct smu_context *smu,
|
||||
MetricsMember_t member,
|
||||
uint32_t *value)
|
||||
{
|
||||
struct smu_table_context *smu_table = &smu->smu_table;
|
||||
|
||||
SmuMetrics_legacy_t *metrics = (SmuMetrics_legacy_t *)smu_table->metrics_table;
|
||||
int ret = 0;
|
||||
|
||||
ret = smu_cmn_get_metrics_table(smu, NULL, false);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
switch (member) {
|
||||
case METRICS_AVERAGE_GFXCLK:
|
||||
*value = metrics->GfxclkFrequency;
|
||||
break;
|
||||
case METRICS_AVERAGE_SOCCLK:
|
||||
*value = metrics->SocclkFrequency;
|
||||
break;
|
||||
case METRICS_AVERAGE_VCLK:
|
||||
*value = metrics->VclkFrequency;
|
||||
break;
|
||||
case METRICS_AVERAGE_DCLK:
|
||||
*value = metrics->DclkFrequency;
|
||||
break;
|
||||
case METRICS_AVERAGE_UCLK:
|
||||
*value = metrics->MemclkFrequency;
|
||||
break;
|
||||
case METRICS_AVERAGE_GFXACTIVITY:
|
||||
*value = metrics->GfxActivity / 100;
|
||||
break;
|
||||
case METRICS_AVERAGE_FCLK:
|
||||
*value = metrics->AverageFclkFrequency;
|
||||
break;
|
||||
case METRICS_AVERAGE_VCNACTIVITY:
|
||||
*value = metrics->UvdActivity;
|
||||
break;
|
||||
case METRICS_AVERAGE_SOCKETPOWER:
|
||||
*value = (metrics->AverageSocketPower << 8) / 1000;
|
||||
break;
|
||||
case METRICS_CURR_SOCKETPOWER:
|
||||
*value = (metrics->CurrentSocketPower << 8) / 1000;
|
||||
break;
|
||||
case METRICS_TEMPERATURE_EDGE:
|
||||
*value = metrics->GfxTemperature / 100 *
|
||||
SMU_TEMPERATURE_UNITS_PER_CENTIGRADES;
|
||||
break;
|
||||
case METRICS_TEMPERATURE_HOTSPOT:
|
||||
*value = metrics->SocTemperature / 100 *
|
||||
SMU_TEMPERATURE_UNITS_PER_CENTIGRADES;
|
||||
break;
|
||||
case METRICS_THROTTLER_STATUS:
|
||||
*value = metrics->ThrottlerStatus;
|
||||
break;
|
||||
case METRICS_VOLTAGE_VDDGFX:
|
||||
*value = metrics->Voltage[0];
|
||||
break;
|
||||
case METRICS_VOLTAGE_VDDSOC:
|
||||
*value = metrics->Voltage[1];
|
||||
break;
|
||||
case METRICS_SS_APU_SHARE:
|
||||
/* return the percentage of APU power with respect to APU's power limit.
|
||||
* percentage is reported, this isn't boost value. Smartshift power
|
||||
* boost/shift is only when the percentage is more than 100.
|
||||
*/
|
||||
if (metrics->StapmOpnLimit > 0)
|
||||
*value = (metrics->ApuPower * 100) / metrics->StapmOpnLimit;
|
||||
else
|
||||
*value = 0;
|
||||
break;
|
||||
case METRICS_SS_DGPU_SHARE:
|
||||
/* return the percentage of dGPU power with respect to dGPU's power limit.
|
||||
* percentage is reported, this isn't boost value. Smartshift power
|
||||
* boost/shift is only when the percentage is more than 100.
|
||||
*/
|
||||
if ((metrics->dGpuPower > 0) &&
|
||||
(metrics->StapmCurrentLimit > metrics->StapmOpnLimit))
|
||||
*value = (metrics->dGpuPower * 100) /
|
||||
(metrics->StapmCurrentLimit - metrics->StapmOpnLimit);
|
||||
else
|
||||
*value = 0;
|
||||
break;
|
||||
default:
|
||||
*value = UINT_MAX;
|
||||
break;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int smu_v14_0_0_common_get_smu_metrics_data(struct smu_context *smu,
|
||||
MetricsMember_t member,
|
||||
uint32_t *value)
|
||||
{
|
||||
if (smu->smc_fw_version > 0x5d3500)
|
||||
return smu_v14_0_0_get_smu_metrics_data(smu, member, value);
|
||||
else
|
||||
return smu_v14_0_0_legacy_get_smu_metrics_data(smu, member, value);
|
||||
}
|
||||
|
||||
static int smu_v14_0_0_read_sensor(struct smu_context *smu,
|
||||
enum amd_pp_sensors sensor,
|
||||
void *data, uint32_t *size)
|
||||
@ -429,69 +320,69 @@ static int smu_v14_0_0_read_sensor(struct smu_context *smu,
|
||||
|
||||
switch (sensor) {
|
||||
case AMDGPU_PP_SENSOR_GPU_LOAD:
|
||||
ret = smu_v14_0_0_common_get_smu_metrics_data(smu,
|
||||
ret = smu_v14_0_0_get_smu_metrics_data(smu,
|
||||
METRICS_AVERAGE_GFXACTIVITY,
|
||||
(uint32_t *)data);
|
||||
*size = 4;
|
||||
break;
|
||||
case AMDGPU_PP_SENSOR_GPU_AVG_POWER:
|
||||
ret = smu_v14_0_0_common_get_smu_metrics_data(smu,
|
||||
ret = smu_v14_0_0_get_smu_metrics_data(smu,
|
||||
METRICS_AVERAGE_SOCKETPOWER,
|
||||
(uint32_t *)data);
|
||||
*size = 4;
|
||||
break;
|
||||
case AMDGPU_PP_SENSOR_GPU_INPUT_POWER:
|
||||
ret = smu_v14_0_0_common_get_smu_metrics_data(smu,
|
||||
ret = smu_v14_0_0_get_smu_metrics_data(smu,
|
||||
METRICS_CURR_SOCKETPOWER,
|
||||
(uint32_t *)data);
|
||||
*size = 4;
|
||||
break;
|
||||
case AMDGPU_PP_SENSOR_EDGE_TEMP:
|
||||
ret = smu_v14_0_0_common_get_smu_metrics_data(smu,
|
||||
ret = smu_v14_0_0_get_smu_metrics_data(smu,
|
||||
METRICS_TEMPERATURE_EDGE,
|
||||
(uint32_t *)data);
|
||||
*size = 4;
|
||||
break;
|
||||
case AMDGPU_PP_SENSOR_HOTSPOT_TEMP:
|
||||
ret = smu_v14_0_0_common_get_smu_metrics_data(smu,
|
||||
ret = smu_v14_0_0_get_smu_metrics_data(smu,
|
||||
METRICS_TEMPERATURE_HOTSPOT,
|
||||
(uint32_t *)data);
|
||||
*size = 4;
|
||||
break;
|
||||
case AMDGPU_PP_SENSOR_GFX_MCLK:
|
||||
ret = smu_v14_0_0_common_get_smu_metrics_data(smu,
|
||||
ret = smu_v14_0_0_get_smu_metrics_data(smu,
|
||||
METRICS_AVERAGE_UCLK,
|
||||
(uint32_t *)data);
|
||||
*(uint32_t *)data *= 100;
|
||||
*size = 4;
|
||||
break;
|
||||
case AMDGPU_PP_SENSOR_GFX_SCLK:
|
||||
ret = smu_v14_0_0_common_get_smu_metrics_data(smu,
|
||||
ret = smu_v14_0_0_get_smu_metrics_data(smu,
|
||||
METRICS_AVERAGE_GFXCLK,
|
||||
(uint32_t *)data);
|
||||
*(uint32_t *)data *= 100;
|
||||
*size = 4;
|
||||
break;
|
||||
case AMDGPU_PP_SENSOR_VDDGFX:
|
||||
ret = smu_v14_0_0_common_get_smu_metrics_data(smu,
|
||||
ret = smu_v14_0_0_get_smu_metrics_data(smu,
|
||||
METRICS_VOLTAGE_VDDGFX,
|
||||
(uint32_t *)data);
|
||||
*size = 4;
|
||||
break;
|
||||
case AMDGPU_PP_SENSOR_VDDNB:
|
||||
ret = smu_v14_0_0_common_get_smu_metrics_data(smu,
|
||||
ret = smu_v14_0_0_get_smu_metrics_data(smu,
|
||||
METRICS_VOLTAGE_VDDSOC,
|
||||
(uint32_t *)data);
|
||||
*size = 4;
|
||||
break;
|
||||
case AMDGPU_PP_SENSOR_SS_APU_SHARE:
|
||||
ret = smu_v14_0_0_common_get_smu_metrics_data(smu,
|
||||
ret = smu_v14_0_0_get_smu_metrics_data(smu,
|
||||
METRICS_SS_APU_SHARE,
|
||||
(uint32_t *)data);
|
||||
*size = 4;
|
||||
break;
|
||||
case AMDGPU_PP_SENSOR_SS_DGPU_SHARE:
|
||||
ret = smu_v14_0_0_common_get_smu_metrics_data(smu,
|
||||
ret = smu_v14_0_0_get_smu_metrics_data(smu,
|
||||
METRICS_SS_DGPU_SHARE,
|
||||
(uint32_t *)data);
|
||||
*size = 4;
|
||||
@ -588,7 +479,7 @@ static ssize_t smu_v14_0_0_get_gpu_metrics(struct smu_context *smu,
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
smu_cmn_init_soft_gpu_metrics(gpu_metrics, 2, 1);
|
||||
smu_cmn_init_soft_gpu_metrics(gpu_metrics, 3, 0);
|
||||
|
||||
gpu_metrics->temperature_gfx = metrics.GfxTemperature;
|
||||
gpu_metrics->temperature_soc = metrics.SocTemperature;
|
||||
@ -597,32 +488,33 @@ static ssize_t smu_v14_0_0_get_gpu_metrics(struct smu_context *smu,
|
||||
sizeof(uint16_t) * 16);
|
||||
gpu_metrics->temperature_skin = metrics.SkinTemp;
|
||||
|
||||
gpu_metrics->average_gfx_activity = metrics.AverageGfxActivity;
|
||||
gpu_metrics->average_vcn_activity = metrics.AverageVcnActivity;
|
||||
gpu_metrics->average_gfx_activity = metrics.GfxActivity;
|
||||
gpu_metrics->average_vcn_activity = metrics.VcnActivity;
|
||||
memcpy(&gpu_metrics->average_ipu_activity[0],
|
||||
&metrics.AverageIpuBusy[0],
|
||||
&metrics.IpuBusy[0],
|
||||
sizeof(uint16_t) * 8);
|
||||
memcpy(&gpu_metrics->average_core_c0_activity[0],
|
||||
&metrics.AverageCoreC0Residency[0],
|
||||
&metrics.CoreC0Residency[0],
|
||||
sizeof(uint16_t) * 16);
|
||||
gpu_metrics->average_dram_reads = metrics.AverageDRAMReads;
|
||||
gpu_metrics->average_dram_writes = metrics.AverageDRAMWrites;
|
||||
gpu_metrics->average_dram_reads = metrics.DRAMReads;
|
||||
gpu_metrics->average_dram_writes = metrics.DRAMWrites;
|
||||
|
||||
gpu_metrics->average_socket_power = metrics.AverageSocketPower;
|
||||
gpu_metrics->average_socket_power = metrics.SocketPower;
|
||||
gpu_metrics->average_ipu_power = metrics.IpuPower;
|
||||
gpu_metrics->average_apu_power = metrics.ApuPower;
|
||||
gpu_metrics->average_gfx_power = metrics.GfxPower;
|
||||
gpu_metrics->average_dgpu_power = metrics.dGpuPower;
|
||||
gpu_metrics->average_core_power = metrics.AverageCorePower;
|
||||
memcpy(&gpu_metrics->core_power[0],
|
||||
gpu_metrics->average_all_core_power = metrics.AllCorePower;
|
||||
memcpy(&gpu_metrics->average_core_power[0],
|
||||
&metrics.CorePower[0],
|
||||
sizeof(uint16_t) * 16);
|
||||
|
||||
gpu_metrics->average_gfxclk_frequency = metrics.AverageGfxclkFrequency;
|
||||
gpu_metrics->average_socclk_frequency = metrics.AverageSocclkFrequency;
|
||||
gpu_metrics->average_vpeclk_frequency = metrics.AverageVpeclkFrequency;
|
||||
gpu_metrics->average_fclk_frequency = metrics.AverageFclkFrequency;
|
||||
gpu_metrics->average_vclk_frequency = metrics.AverageVclkFrequency;
|
||||
gpu_metrics->average_ipuclk_frequency = metrics.AverageIpuclkFrequency;
|
||||
gpu_metrics->average_gfxclk_frequency = metrics.GfxclkFrequency;
|
||||
gpu_metrics->average_socclk_frequency = metrics.SocclkFrequency;
|
||||
gpu_metrics->average_vpeclk_frequency = metrics.VpeclkFrequency;
|
||||
gpu_metrics->average_fclk_frequency = metrics.FclkFrequency;
|
||||
gpu_metrics->average_vclk_frequency = metrics.VclkFrequency;
|
||||
gpu_metrics->average_ipuclk_frequency = metrics.IpuclkFrequency;
|
||||
|
||||
memcpy(&gpu_metrics->current_coreclk[0],
|
||||
&metrics.CoreFrequency[0],
|
||||
@ -638,68 +530,6 @@ static ssize_t smu_v14_0_0_get_gpu_metrics(struct smu_context *smu,
|
||||
return sizeof(struct gpu_metrics_v3_0);
|
||||
}
|
||||
|
||||
static ssize_t smu_v14_0_0_get_legacy_gpu_metrics(struct smu_context *smu,
|
||||
void **table)
|
||||
{
|
||||
struct smu_table_context *smu_table = &smu->smu_table;
|
||||
struct gpu_metrics_v2_1 *gpu_metrics =
|
||||
(struct gpu_metrics_v2_1 *)smu_table->gpu_metrics_table;
|
||||
SmuMetrics_legacy_t metrics;
|
||||
int ret = 0;
|
||||
|
||||
ret = smu_cmn_get_metrics_table(smu, &metrics, true);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
smu_cmn_init_soft_gpu_metrics(gpu_metrics, 2, 1);
|
||||
|
||||
gpu_metrics->temperature_gfx = metrics.GfxTemperature;
|
||||
gpu_metrics->temperature_soc = metrics.SocTemperature;
|
||||
memcpy(&gpu_metrics->temperature_core[0],
|
||||
&metrics.CoreTemperature[0],
|
||||
sizeof(uint16_t) * 8);
|
||||
gpu_metrics->temperature_l3[0] = metrics.L3Temperature[0];
|
||||
gpu_metrics->temperature_l3[1] = metrics.L3Temperature[1];
|
||||
|
||||
gpu_metrics->average_gfx_activity = metrics.GfxActivity;
|
||||
gpu_metrics->average_mm_activity = metrics.UvdActivity;
|
||||
|
||||
gpu_metrics->average_socket_power = metrics.CurrentSocketPower;
|
||||
gpu_metrics->average_gfx_power = metrics.Power[0];
|
||||
gpu_metrics->average_soc_power = metrics.Power[1];
|
||||
memcpy(&gpu_metrics->average_core_power[0],
|
||||
&metrics.CorePower[0],
|
||||
sizeof(uint16_t) * 8);
|
||||
|
||||
gpu_metrics->average_gfxclk_frequency = metrics.GfxclkFrequency;
|
||||
gpu_metrics->average_socclk_frequency = metrics.SocclkFrequency;
|
||||
gpu_metrics->average_uclk_frequency = metrics.MemclkFrequency;
|
||||
gpu_metrics->average_fclk_frequency = metrics.MemclkFrequency;
|
||||
gpu_metrics->average_vclk_frequency = metrics.VclkFrequency;
|
||||
gpu_metrics->average_dclk_frequency = metrics.DclkFrequency;
|
||||
|
||||
memcpy(&gpu_metrics->current_coreclk[0],
|
||||
&metrics.CoreFrequency[0],
|
||||
sizeof(uint16_t) * 8);
|
||||
|
||||
gpu_metrics->throttle_status = metrics.ThrottlerStatus;
|
||||
gpu_metrics->system_clock_counter = ktime_get_boottime_ns();
|
||||
|
||||
*table = (void *)gpu_metrics;
|
||||
|
||||
return sizeof(struct gpu_metrics_v2_1);
|
||||
}
|
||||
|
||||
static ssize_t smu_v14_0_0_common_get_gpu_metrics(struct smu_context *smu,
|
||||
void **table)
|
||||
{
|
||||
|
||||
if (smu->smc_fw_version > 0x5d3500)
|
||||
return smu_v14_0_0_get_gpu_metrics(smu, table);
|
||||
else
|
||||
return smu_v14_0_0_get_legacy_gpu_metrics(smu, table);
|
||||
}
|
||||
|
||||
static int smu_v14_0_0_mode2_reset(struct smu_context *smu)
|
||||
{
|
||||
int ret;
|
||||
@ -928,7 +758,7 @@ static int smu_v14_0_0_get_current_clk_freq(struct smu_context *smu,
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return smu_v14_0_0_common_get_smu_metrics_data(smu, member_type, value);
|
||||
return smu_v14_0_0_get_smu_metrics_data(smu, member_type, value);
|
||||
}
|
||||
|
||||
static int smu_v14_0_0_get_dpm_level_count(struct smu_context *smu,
|
||||
@ -1230,7 +1060,7 @@ static const struct pptable_funcs smu_v14_0_0_ppt_funcs = {
|
||||
.read_sensor = smu_v14_0_0_read_sensor,
|
||||
.is_dpm_running = smu_v14_0_0_is_dpm_running,
|
||||
.set_watermarks_table = smu_v14_0_0_set_watermarks_table,
|
||||
.get_gpu_metrics = smu_v14_0_0_common_get_gpu_metrics,
|
||||
.get_gpu_metrics = smu_v14_0_0_get_gpu_metrics,
|
||||
.get_enabled_mask = smu_cmn_get_enabled_mask,
|
||||
.get_pp_feature_mask = smu_cmn_get_pp_feature_mask,
|
||||
.set_driver_table_location = smu_v14_0_set_driver_table_location,
|
||||
|
@ -1004,6 +1004,9 @@ void smu_cmn_init_soft_gpu_metrics(void *table, uint8_t frev, uint8_t crev)
|
||||
case METRICS_VERSION(2, 4):
|
||||
structure_size = sizeof(struct gpu_metrics_v2_4);
|
||||
break;
|
||||
case METRICS_VERSION(3, 0):
|
||||
structure_size = sizeof(struct gpu_metrics_v3_0);
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
|
@ -3893,7 +3893,7 @@ typedef struct _ATOM_GPIO_PIN_ASSIGNMENT
|
||||
typedef struct _ATOM_GPIO_PIN_LUT
|
||||
{
|
||||
ATOM_COMMON_TABLE_HEADER sHeader;
|
||||
ATOM_GPIO_PIN_ASSIGNMENT asGPIO_Pin[1];
|
||||
ATOM_GPIO_PIN_ASSIGNMENT asGPIO_Pin[];
|
||||
}ATOM_GPIO_PIN_LUT;
|
||||
|
||||
/****************************************************************************/
|
||||
@ -4061,7 +4061,7 @@ typedef struct _ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT //usSrcDstTableOffset
|
||||
UCHAR ucNumberOfSrc;
|
||||
USHORT usSrcObjectID[1];
|
||||
UCHAR ucNumberOfDst;
|
||||
USHORT usDstObjectID[1];
|
||||
USHORT usDstObjectID[];
|
||||
}ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT;
|
||||
|
||||
|
||||
@ -4233,7 +4233,7 @@ typedef struct _ATOM_CONNECTOR_DEVICE_TAG_RECORD
|
||||
ATOM_COMMON_RECORD_HEADER sheader;
|
||||
UCHAR ucNumberOfDevice;
|
||||
UCHAR ucReserved;
|
||||
ATOM_CONNECTOR_DEVICE_TAG asDeviceTag[1]; //This Id is same as "ATOM_DEVICE_XXX_SUPPORT", 1 is only for allocation
|
||||
ATOM_CONNECTOR_DEVICE_TAG asDeviceTag[]; //This Id is same as "ATOM_DEVICE_XXX_SUPPORT", 1 is only for allocation
|
||||
}ATOM_CONNECTOR_DEVICE_TAG_RECORD;
|
||||
|
||||
|
||||
@ -4293,7 +4293,7 @@ typedef struct _ATOM_OBJECT_GPIO_CNTL_RECORD
|
||||
ATOM_COMMON_RECORD_HEADER sheader;
|
||||
UCHAR ucFlags; // Future expnadibility
|
||||
UCHAR ucNumberOfPins; // Number of GPIO pins used to control the object
|
||||
ATOM_GPIO_PIN_CONTROL_PAIR asGpio[1]; // the real gpio pin pair determined by number of pins ucNumberOfPins
|
||||
ATOM_GPIO_PIN_CONTROL_PAIR asGpio[]; // the real gpio pin pair determined by number of pins ucNumberOfPins
|
||||
}ATOM_OBJECT_GPIO_CNTL_RECORD;
|
||||
|
||||
//Definitions for GPIO pin state
|
||||
@ -4444,7 +4444,7 @@ typedef struct _ATOM_BRACKET_LAYOUT_RECORD
|
||||
UCHAR ucWidth;
|
||||
UCHAR ucConnNum;
|
||||
UCHAR ucReserved;
|
||||
ATOM_CONNECTOR_LAYOUT_INFO asConnInfo[1];
|
||||
ATOM_CONNECTOR_LAYOUT_INFO asConnInfo[];
|
||||
}ATOM_BRACKET_LAYOUT_RECORD;
|
||||
|
||||
/****************************************************************************/
|
||||
@ -4600,7 +4600,7 @@ typedef struct _ATOM_I2C_VOLTAGE_OBJECT_V3
|
||||
UCHAR ucVoltageControlAddress;
|
||||
UCHAR ucVoltageControlOffset;
|
||||
ULONG ulReserved;
|
||||
VOLTAGE_LUT_ENTRY asVolI2cLut[1]; // end with 0xff
|
||||
VOLTAGE_LUT_ENTRY asVolI2cLut[]; // end with 0xff
|
||||
}ATOM_I2C_VOLTAGE_OBJECT_V3;
|
||||
|
||||
// ATOM_I2C_VOLTAGE_OBJECT_V3.ucVoltageControlFlag
|
||||
@ -4625,7 +4625,7 @@ typedef struct _ATOM_LEAKAGE_VOLTAGE_OBJECT_V3
|
||||
UCHAR ucLeakageEntryNum; // indicate the entry number of LeakageId/Voltage Lut table
|
||||
UCHAR ucReserved[2];
|
||||
ULONG ulMaxVoltageLevel;
|
||||
LEAKAGE_VOLTAGE_LUT_ENTRY_V2 asLeakageIdLut[1];
|
||||
LEAKAGE_VOLTAGE_LUT_ENTRY_V2 asLeakageIdLut[];
|
||||
}ATOM_LEAKAGE_VOLTAGE_OBJECT_V3;
|
||||
|
||||
|
||||
@ -4753,7 +4753,7 @@ typedef struct _ATOM_POWER_SOURCE_INFO
|
||||
{
|
||||
ATOM_COMMON_TABLE_HEADER asHeader;
|
||||
UCHAR asPwrbehave[16];
|
||||
ATOM_POWER_SOURCE_OBJECT asPwrObj[1];
|
||||
ATOM_POWER_SOURCE_OBJECT asPwrObj[];
|
||||
}ATOM_POWER_SOURCE_INFO;
|
||||
|
||||
|
||||
@ -5440,7 +5440,7 @@ typedef struct _ATOM_FUSION_SYSTEM_INFO_V2
|
||||
typedef struct _ATOM_I2C_DATA_RECORD
|
||||
{
|
||||
UCHAR ucNunberOfBytes; //Indicates how many bytes SW needs to write to the external ASIC for one block, besides to "Start" and "Stop"
|
||||
UCHAR ucI2CData[1]; //I2C data in bytes, should be less than 16 bytes usually
|
||||
UCHAR ucI2CData[]; //I2C data in bytes, should be less than 16 bytes usually
|
||||
}ATOM_I2C_DATA_RECORD;
|
||||
|
||||
|
||||
@ -5451,14 +5451,14 @@ typedef struct _ATOM_I2C_DEVICE_SETUP_INFO
|
||||
UCHAR ucSSChipID; //SS chip being used
|
||||
UCHAR ucSSChipSlaveAddr; //Slave Address to set up this SS chip
|
||||
UCHAR ucNumOfI2CDataRecords; //number of data block
|
||||
ATOM_I2C_DATA_RECORD asI2CData[1];
|
||||
ATOM_I2C_DATA_RECORD asI2CData[];
|
||||
}ATOM_I2C_DEVICE_SETUP_INFO;
|
||||
|
||||
//==========================================================================================
|
||||
typedef struct _ATOM_ASIC_MVDD_INFO
|
||||
{
|
||||
ATOM_COMMON_TABLE_HEADER sHeader;
|
||||
ATOM_I2C_DEVICE_SETUP_INFO asI2CSetup[1];
|
||||
ATOM_I2C_DEVICE_SETUP_INFO asI2CSetup[];
|
||||
}ATOM_ASIC_MVDD_INFO;
|
||||
|
||||
//==========================================================================================
|
||||
@ -5520,7 +5520,7 @@ typedef struct _ATOM_ASIC_INTERNAL_SS_INFO
|
||||
typedef struct _ATOM_ASIC_INTERNAL_SS_INFO_V2
|
||||
{
|
||||
ATOM_COMMON_TABLE_HEADER sHeader;
|
||||
ATOM_ASIC_SS_ASSIGNMENT_V2 asSpreadSpectrum[1]; //this is point only.
|
||||
ATOM_ASIC_SS_ASSIGNMENT_V2 asSpreadSpectrum[]; //this is point only.
|
||||
}ATOM_ASIC_INTERNAL_SS_INFO_V2;
|
||||
|
||||
typedef struct _ATOM_ASIC_SS_ASSIGNMENT_V3
|
||||
@ -5542,7 +5542,7 @@ typedef struct _ATOM_ASIC_SS_ASSIGNMENT_V3
|
||||
typedef struct _ATOM_ASIC_INTERNAL_SS_INFO_V3
|
||||
{
|
||||
ATOM_COMMON_TABLE_HEADER sHeader;
|
||||
ATOM_ASIC_SS_ASSIGNMENT_V3 asSpreadSpectrum[1]; //this is pointer only.
|
||||
ATOM_ASIC_SS_ASSIGNMENT_V3 asSpreadSpectrum[]; //this is pointer only.
|
||||
}ATOM_ASIC_INTERNAL_SS_INFO_V3;
|
||||
|
||||
|
||||
@ -6282,7 +6282,7 @@ typedef union _ATOM_MEMORY_SETTING_ID_CONFIG_ACCESS
|
||||
|
||||
typedef struct _ATOM_MEMORY_SETTING_DATA_BLOCK{
|
||||
ATOM_MEMORY_SETTING_ID_CONFIG_ACCESS ulMemoryID;
|
||||
ULONG aulMemData[1];
|
||||
ULONG aulMemData[];
|
||||
}ATOM_MEMORY_SETTING_DATA_BLOCK;
|
||||
|
||||
|
||||
@ -7092,7 +7092,7 @@ typedef struct _ATOM_DISP_OUT_INFO_V3
|
||||
UCHAR ucCoreRefClkSource; // value of CORE_REF_CLK_SOURCE
|
||||
UCHAR ucDispCaps;
|
||||
UCHAR ucReserved[2];
|
||||
ASIC_TRANSMITTER_INFO_V2 asTransmitterInfo[1]; // for alligment only
|
||||
ASIC_TRANSMITTER_INFO_V2 asTransmitterInfo[]; // for alligment only
|
||||
}ATOM_DISP_OUT_INFO_V3;
|
||||
|
||||
//ucDispCaps
|
||||
@ -7324,12 +7324,12 @@ typedef struct _CLOCK_CONDITION_SETTING_ENTRY{
|
||||
USHORT usMaxClockFreq;
|
||||
UCHAR ucEncodeMode;
|
||||
UCHAR ucPhySel;
|
||||
ULONG ulAnalogSetting[1];
|
||||
ULONG ulAnalogSetting[];
|
||||
}CLOCK_CONDITION_SETTING_ENTRY;
|
||||
|
||||
typedef struct _CLOCK_CONDITION_SETTING_INFO{
|
||||
USHORT usEntrySize;
|
||||
CLOCK_CONDITION_SETTING_ENTRY asClkCondSettingEntry[1];
|
||||
CLOCK_CONDITION_SETTING_ENTRY asClkCondSettingEntry[];
|
||||
}CLOCK_CONDITION_SETTING_INFO;
|
||||
|
||||
typedef struct _PHY_CONDITION_REG_VAL{
|
||||
@ -7346,27 +7346,27 @@ typedef struct _PHY_CONDITION_REG_VAL_V2{
|
||||
typedef struct _PHY_CONDITION_REG_INFO{
|
||||
USHORT usRegIndex;
|
||||
USHORT usSize;
|
||||
PHY_CONDITION_REG_VAL asRegVal[1];
|
||||
PHY_CONDITION_REG_VAL asRegVal[];
|
||||
}PHY_CONDITION_REG_INFO;
|
||||
|
||||
typedef struct _PHY_CONDITION_REG_INFO_V2{
|
||||
USHORT usRegIndex;
|
||||
USHORT usSize;
|
||||
PHY_CONDITION_REG_VAL_V2 asRegVal[1];
|
||||
PHY_CONDITION_REG_VAL_V2 asRegVal[];
|
||||
}PHY_CONDITION_REG_INFO_V2;
|
||||
|
||||
typedef struct _PHY_ANALOG_SETTING_INFO{
|
||||
UCHAR ucEncodeMode;
|
||||
UCHAR ucPhySel;
|
||||
USHORT usSize;
|
||||
PHY_CONDITION_REG_INFO asAnalogSetting[1];
|
||||
PHY_CONDITION_REG_INFO asAnalogSetting[];
|
||||
}PHY_ANALOG_SETTING_INFO;
|
||||
|
||||
typedef struct _PHY_ANALOG_SETTING_INFO_V2{
|
||||
UCHAR ucEncodeMode;
|
||||
UCHAR ucPhySel;
|
||||
USHORT usSize;
|
||||
PHY_CONDITION_REG_INFO_V2 asAnalogSetting[1];
|
||||
PHY_CONDITION_REG_INFO_V2 asAnalogSetting[];
|
||||
}PHY_ANALOG_SETTING_INFO_V2;
|
||||
|
||||
typedef struct _GFX_HAVESTING_PARAMETERS {
|
||||
|
@ -68,4 +68,9 @@ enum amd_asic_type {
|
||||
|
||||
extern const char *amdgpu_asic_name[];
|
||||
|
||||
struct amdgpu_asic_type_quirk {
|
||||
unsigned short device; /* PCI device ID */
|
||||
u8 revision; /* revision ID */
|
||||
unsigned short type; /* real ASIC type */
|
||||
};
|
||||
#endif /*__AMD_ASIC_TYPE_H__ */
|
||||
|
Loading…
Reference in New Issue
Block a user