From: Greg Kroah-Hartman Date: Wed, 9 Aug 2023 09:09:43 +0000 (+0200) Subject: 6.1-stable patches X-Git-Tag: v4.14.322~13 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=1b8e6409365b03423e1f30329c19927067ab7126;p=thirdparty%2Fkernel%2Fstable-queue.git 6.1-stable patches added patches: drm-amdgpu-add-vram-reservation-based-on-vram_usagebyfirmware_v2_2.patch drm-amdgpu-remove-unnecessary-domain-argument.patch drm-amdgpu-use-apt-name-for-fw-reserved-region.patch --- diff --git a/queue-6.1/drm-amdgpu-add-vram-reservation-based-on-vram_usagebyfirmware_v2_2.patch b/queue-6.1/drm-amdgpu-add-vram-reservation-based-on-vram_usagebyfirmware_v2_2.patch new file mode 100644 index 00000000000..74935ed1e38 --- /dev/null +++ b/queue-6.1/drm-amdgpu-add-vram-reservation-based-on-vram_usagebyfirmware_v2_2.patch @@ -0,0 +1,322 @@ +From stable-owner@vger.kernel.org Tue Aug 8 20:31:40 2023 +From: Mario Limonciello +Date: Tue, 8 Aug 2023 12:50:53 -0500 +Subject: drm/amdgpu: add vram reservation based on vram_usagebyfirmware_v2_2 +To: +Cc: Mario Limonciello +Message-ID: <20230808175055.3761-2-mario.limonciello@amd.com> + +From: Tong Liu01 + +commit 4864f2ee9ee2acf4a1009b58fbc62f17fa086d4e upstream + +Move TMR region from top of FB to 2MB for FFBM, so we need to +reserve TMR region firstly to make sure TMR can be allocated at 2MB + +Signed-off-by: Tong Liu01 +Acked-by: Christian König +Signed-off-by: Alex Deucher +Signed-off-by: Mario Limonciello +Signed-off-by: Greg Kroah-Hartman +--- + drivers/gpu/drm/amd/amdgpu/amdgpu_atomfirmware.c | 104 +++++++++++++++++------ + drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c | 51 +++++++++++ + drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h | 5 + + drivers/gpu/drm/amd/include/atomfirmware.h | 63 +++++++++++-- + 4 files changed, 191 insertions(+), 32 deletions(-) + +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_atomfirmware.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_atomfirmware.c +@@ -101,39 +101,97 @@ void amdgpu_atomfirmware_scratch_regs_in + } + } + ++static int amdgpu_atomfirmware_allocate_fb_v2_1(struct amdgpu_device *adev, ++ struct vram_usagebyfirmware_v2_1 *fw_usage, int *usage_bytes) ++{ ++ uint32_t start_addr, fw_size, drv_size; ++ ++ start_addr = le32_to_cpu(fw_usage->start_address_in_kb); ++ fw_size = le16_to_cpu(fw_usage->used_by_firmware_in_kb); ++ drv_size = le16_to_cpu(fw_usage->used_by_driver_in_kb); ++ ++ DRM_DEBUG("atom firmware v2_1 requested %08x %dkb fw %dkb drv\n", ++ start_addr, ++ fw_size, ++ drv_size); ++ ++ if ((start_addr & ATOM_VRAM_OPERATION_FLAGS_MASK) == ++ (uint32_t)(ATOM_VRAM_BLOCK_SRIOV_MSG_SHARE_RESERVATION << ++ ATOM_VRAM_OPERATION_FLAGS_SHIFT)) { ++ /* Firmware request VRAM reservation for SR-IOV */ ++ adev->mman.fw_vram_usage_start_offset = (start_addr & ++ (~ATOM_VRAM_OPERATION_FLAGS_MASK)) << 10; ++ adev->mman.fw_vram_usage_size = fw_size << 10; ++ /* Use the default scratch size */ ++ *usage_bytes = 0; ++ } else { ++ *usage_bytes = drv_size << 10; ++ } ++ return 0; ++} ++ ++static int amdgpu_atomfirmware_allocate_fb_v2_2(struct amdgpu_device *adev, ++ struct vram_usagebyfirmware_v2_2 *fw_usage, int *usage_bytes) ++{ ++ uint32_t fw_start_addr, fw_size, drv_start_addr, drv_size; ++ ++ fw_start_addr = le32_to_cpu(fw_usage->fw_region_start_address_in_kb); ++ fw_size = le16_to_cpu(fw_usage->used_by_firmware_in_kb); ++ ++ drv_start_addr = le32_to_cpu(fw_usage->driver_region0_start_address_in_kb); ++ drv_size = le32_to_cpu(fw_usage->used_by_driver_region0_in_kb); ++ ++ DRM_DEBUG("atom requested fw start at %08x %dkb and drv start at %08x %dkb\n", ++ fw_start_addr, ++ fw_size, ++ drv_start_addr, ++ drv_size); ++ ++ if ((fw_start_addr & (ATOM_VRAM_BLOCK_NEEDS_NO_RESERVATION << 30)) == 0) { ++ /* Firmware request VRAM reservation for SR-IOV */ ++ adev->mman.fw_vram_usage_start_offset = (fw_start_addr & ++ (~ATOM_VRAM_OPERATION_FLAGS_MASK)) << 10; ++ adev->mman.fw_vram_usage_size = fw_size << 10; ++ } ++ ++ if ((drv_start_addr & (ATOM_VRAM_BLOCK_NEEDS_NO_RESERVATION << 30)) == 0) { ++ /* driver request VRAM reservation for SR-IOV */ ++ adev->mman.drv_vram_usage_start_offset = (drv_start_addr & ++ (~ATOM_VRAM_OPERATION_FLAGS_MASK)) << 10; ++ adev->mman.drv_vram_usage_size = drv_size << 10; ++ } ++ ++ *usage_bytes = 0; ++ return 0; ++} ++ + int amdgpu_atomfirmware_allocate_fb_scratch(struct amdgpu_device *adev) + { + struct atom_context *ctx = adev->mode_info.atom_context; + int index = get_index_into_master_table(atom_master_list_of_data_tables_v2_1, + vram_usagebyfirmware); +- struct vram_usagebyfirmware_v2_1 *firmware_usage; +- uint32_t start_addr, size; ++ struct vram_usagebyfirmware_v2_1 *fw_usage_v2_1; ++ struct vram_usagebyfirmware_v2_2 *fw_usage_v2_2; + uint16_t data_offset; ++ uint8_t frev, crev; + int usage_bytes = 0; + +- if (amdgpu_atom_parse_data_header(ctx, index, NULL, NULL, NULL, &data_offset)) { +- firmware_usage = (struct vram_usagebyfirmware_v2_1 *)(ctx->bios + data_offset); +- DRM_DEBUG("atom firmware requested %08x %dkb fw %dkb drv\n", +- le32_to_cpu(firmware_usage->start_address_in_kb), +- le16_to_cpu(firmware_usage->used_by_firmware_in_kb), +- le16_to_cpu(firmware_usage->used_by_driver_in_kb)); +- +- start_addr = le32_to_cpu(firmware_usage->start_address_in_kb); +- size = le16_to_cpu(firmware_usage->used_by_firmware_in_kb); +- +- if ((uint32_t)(start_addr & ATOM_VRAM_OPERATION_FLAGS_MASK) == +- (uint32_t)(ATOM_VRAM_BLOCK_SRIOV_MSG_SHARE_RESERVATION << +- ATOM_VRAM_OPERATION_FLAGS_SHIFT)) { +- /* Firmware request VRAM reservation for SR-IOV */ +- adev->mman.fw_vram_usage_start_offset = (start_addr & +- (~ATOM_VRAM_OPERATION_FLAGS_MASK)) << 10; +- adev->mman.fw_vram_usage_size = size << 10; +- /* Use the default scratch size */ +- usage_bytes = 0; +- } else { +- usage_bytes = le16_to_cpu(firmware_usage->used_by_driver_in_kb) << 10; ++ if (amdgpu_atom_parse_data_header(ctx, index, NULL, &frev, &crev, &data_offset)) { ++ if (frev == 2 && crev == 1) { ++ fw_usage_v2_1 = ++ (struct vram_usagebyfirmware_v2_1 *)(ctx->bios + data_offset); ++ amdgpu_atomfirmware_allocate_fb_v2_1(adev, ++ fw_usage_v2_1, ++ &usage_bytes); ++ } else if (frev >= 2 && crev >= 2) { ++ fw_usage_v2_2 = ++ (struct vram_usagebyfirmware_v2_2 *)(ctx->bios + data_offset); ++ amdgpu_atomfirmware_allocate_fb_v2_2(adev, ++ fw_usage_v2_2, ++ &usage_bytes); + } + } ++ + ctx->scratch_size_bytes = 0; + if (usage_bytes == 0) + usage_bytes = 20 * 1024; +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c +@@ -1537,6 +1537,23 @@ static void amdgpu_ttm_fw_reserve_vram_f + NULL, &adev->mman.fw_vram_usage_va); + } + ++/* ++ * Driver Reservation functions ++ */ ++/** ++ * amdgpu_ttm_drv_reserve_vram_fini - free drv reserved vram ++ * ++ * @adev: amdgpu_device pointer ++ * ++ * free drv reserved vram if it has been reserved. ++ */ ++static void amdgpu_ttm_drv_reserve_vram_fini(struct amdgpu_device *adev) ++{ ++ amdgpu_bo_free_kernel(&adev->mman.drv_vram_usage_reserved_bo, ++ NULL, ++ NULL); ++} ++ + /** + * amdgpu_ttm_fw_reserve_vram_init - create bo vram reservation from fw + * +@@ -1563,6 +1580,31 @@ static int amdgpu_ttm_fw_reserve_vram_in + &adev->mman.fw_vram_usage_va); + } + ++/** ++ * amdgpu_ttm_drv_reserve_vram_init - create bo vram reservation from driver ++ * ++ * @adev: amdgpu_device pointer ++ * ++ * create bo vram reservation from drv. ++ */ ++static int amdgpu_ttm_drv_reserve_vram_init(struct amdgpu_device *adev) ++{ ++ uint64_t vram_size = adev->gmc.visible_vram_size; ++ ++ adev->mman.drv_vram_usage_reserved_bo = NULL; ++ ++ if (adev->mman.drv_vram_usage_size == 0 || ++ adev->mman.drv_vram_usage_size > vram_size) ++ return 0; ++ ++ return amdgpu_bo_create_kernel_at(adev, ++ adev->mman.drv_vram_usage_start_offset, ++ adev->mman.drv_vram_usage_size, ++ AMDGPU_GEM_DOMAIN_VRAM, ++ &adev->mman.drv_vram_usage_reserved_bo, ++ NULL); ++} ++ + /* + * Memoy training reservation functions + */ +@@ -1731,6 +1773,14 @@ int amdgpu_ttm_init(struct amdgpu_device + } + + /* ++ *The reserved vram for driver must be pinned to the specified ++ *place on the VRAM, so reserve it early. ++ */ ++ r = amdgpu_ttm_drv_reserve_vram_init(adev); ++ if (r) ++ return r; ++ ++ /* + * only NAVI10 and onwards ASIC support for IP discovery. + * If IP discovery enabled, a block of memory should be + * reserved for IP discovey. +@@ -1855,6 +1905,7 @@ void amdgpu_ttm_fini(struct amdgpu_devic + amdgpu_bo_free_kernel(&adev->mman.sdma_access_bo, NULL, + &adev->mman.sdma_access_ptr); + amdgpu_ttm_fw_reserve_vram_fini(adev); ++ amdgpu_ttm_drv_reserve_vram_fini(adev); + + if (drm_dev_enter(adev_to_drm(adev), &idx)) { + +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h +@@ -86,6 +86,11 @@ struct amdgpu_mman { + struct amdgpu_bo *fw_vram_usage_reserved_bo; + void *fw_vram_usage_va; + ++ /* driver VRAM reservation */ ++ u64 drv_vram_usage_start_offset; ++ u64 drv_vram_usage_size; ++ struct amdgpu_bo *drv_vram_usage_reserved_bo; ++ + /* PAGE_SIZE'd BO for process memory r/w over SDMA. */ + struct amdgpu_bo *sdma_access_bo; + void *sdma_access_ptr; +--- a/drivers/gpu/drm/amd/include/atomfirmware.h ++++ b/drivers/gpu/drm/amd/include/atomfirmware.h +@@ -705,20 +705,65 @@ struct atom_gpio_pin_lut_v2_1 + }; + + +-/* +- *************************************************************************** +- Data Table vram_usagebyfirmware structure +- *************************************************************************** +-*/ ++/* ++ * VBIOS/PRE-OS always reserve a FB region at the top of frame buffer. driver should not write ++ * access that region. driver can allocate their own reservation region as long as it does not ++ * overlap firwmare's reservation region. ++ * if (pre-NV1X) atom data table firmwareInfoTable version < 3.3: ++ * in this case, atom data table vram_usagebyfirmwareTable version always <= 2.1 ++ * if VBIOS/UEFI GOP is posted: ++ * VBIOS/UEFIGOP update used_by_firmware_in_kb = total reserved size by VBIOS ++ * update start_address_in_kb = total_mem_size_in_kb - used_by_firmware_in_kb; ++ * ( total_mem_size_in_kb = reg(CONFIG_MEMSIZE)<<10) ++ * driver can allocate driver reservation region under firmware reservation, ++ * used_by_driver_in_kb = driver reservation size ++ * driver reservation start address = (start_address_in_kb - used_by_driver_in_kb) ++ * Comment1[hchan]: There is only one reservation at the beginning of the FB reserved by ++ * host driver. Host driver would overwrite the table with the following ++ * used_by_firmware_in_kb = total reserved size for pf-vf info exchange and ++ * set SRIOV_MSG_SHARE_RESERVATION mask start_address_in_kb = 0 ++ * else there is no VBIOS reservation region: ++ * driver must allocate driver reservation region at top of FB. ++ * driver set used_by_driver_in_kb = driver reservation size ++ * driver reservation start address = (total_mem_size_in_kb - used_by_driver_in_kb) ++ * same as Comment1 ++ * else (NV1X and after): ++ * if VBIOS/UEFI GOP is posted: ++ * VBIOS/UEFIGOP update: ++ * used_by_firmware_in_kb = atom_firmware_Info_v3_3.fw_reserved_size_in_kb; ++ * start_address_in_kb = total_mem_size_in_kb - used_by_firmware_in_kb; ++ * (total_mem_size_in_kb = reg(CONFIG_MEMSIZE)<<10) ++ * if vram_usagebyfirmwareTable version <= 2.1: ++ * driver can allocate driver reservation region under firmware reservation, ++ * driver set used_by_driver_in_kb = driver reservation size ++ * driver reservation start address = start_address_in_kb - used_by_driver_in_kb ++ * same as Comment1 ++ * else driver can: ++ * allocate it reservation any place as long as it does overlap pre-OS FW reservation area ++ * set used_by_driver_region0_in_kb = driver reservation size ++ * set driver_region0_start_address_in_kb = driver reservation region start address ++ * Comment2[hchan]: Host driver can set used_by_firmware_in_kb and start_address_in_kb to ++ * zero as the reservation for VF as it doesn’t exist. And Host driver should also ++ * update atom_firmware_Info table to remove the same VBIOS reservation as well. ++ */ + + struct vram_usagebyfirmware_v2_1 + { +- struct atom_common_table_header table_header; +- uint32_t start_address_in_kb; +- uint16_t used_by_firmware_in_kb; +- uint16_t used_by_driver_in_kb; ++ struct atom_common_table_header table_header; ++ uint32_t start_address_in_kb; ++ uint16_t used_by_firmware_in_kb; ++ uint16_t used_by_driver_in_kb; + }; + ++struct vram_usagebyfirmware_v2_2 { ++ struct atom_common_table_header table_header; ++ uint32_t fw_region_start_address_in_kb; ++ uint16_t used_by_firmware_in_kb; ++ uint16_t reserved; ++ uint32_t driver_region0_start_address_in_kb; ++ uint32_t used_by_driver_region0_in_kb; ++ uint32_t reserved32[7]; ++}; + + /* + *************************************************************************** diff --git a/queue-6.1/drm-amdgpu-remove-unnecessary-domain-argument.patch b/queue-6.1/drm-amdgpu-remove-unnecessary-domain-argument.patch new file mode 100644 index 00000000000..593187aa3ba --- /dev/null +++ b/queue-6.1/drm-amdgpu-remove-unnecessary-domain-argument.patch @@ -0,0 +1,143 @@ +From stable-owner@vger.kernel.org Tue Aug 8 20:31:33 2023 +From: Mario Limonciello +Date: Tue, 8 Aug 2023 12:50:54 -0500 +Subject: drm/amdgpu: Remove unnecessary domain argument +To: +Cc: Mario Limonciello +Message-ID: <20230808175055.3761-3-mario.limonciello@amd.com> + +From: Luben Tuikov + +commit 3273f11675ef11959d25a56df3279f712bcd41b7 upstream + +Remove the "domain" argument to amdgpu_bo_create_kernel_at() since this +function takes an "offset" argument which is the offset off of VRAM, and as +such allocation always takes place in VRAM. Thus, the "domain" argument is +unnecessary. + +Cc: Alex Deucher +Cc: Christian König +Cc: AMD Graphics +Signed-off-by: Luben Tuikov +Reviewed-by: Christian König +Signed-off-by: Alex Deucher +Signed-off-by: Mario Limonciello +Signed-off-by: Greg Kroah-Hartman +--- + drivers/gpu/drm/amd/amdgpu/amdgpu_object.c | 10 +++++----- + drivers/gpu/drm/amd/amdgpu/amdgpu_object.h | 2 +- + drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c | 7 ------- + drivers/gpu/drm/amd/amdgpu/amdgpu_virt.c | 1 - + 4 files changed, 6 insertions(+), 14 deletions(-) + +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c +@@ -347,17 +347,16 @@ int amdgpu_bo_create_kernel(struct amdgp + * @adev: amdgpu device object + * @offset: offset of the BO + * @size: size of the BO +- * @domain: where to place it + * @bo_ptr: used to initialize BOs in structures + * @cpu_addr: optional CPU address mapping + * +- * Creates a kernel BO at a specific offset in the address space of the domain. ++ * Creates a kernel BO at a specific offset in VRAM. + * + * Returns: + * 0 on success, negative error code otherwise. + */ + int amdgpu_bo_create_kernel_at(struct amdgpu_device *adev, +- uint64_t offset, uint64_t size, uint32_t domain, ++ uint64_t offset, uint64_t size, + struct amdgpu_bo **bo_ptr, void **cpu_addr) + { + struct ttm_operation_ctx ctx = { false, false }; +@@ -367,8 +366,9 @@ int amdgpu_bo_create_kernel_at(struct am + offset &= PAGE_MASK; + size = ALIGN(size, PAGE_SIZE); + +- r = amdgpu_bo_create_reserved(adev, size, PAGE_SIZE, domain, bo_ptr, +- NULL, cpu_addr); ++ r = amdgpu_bo_create_reserved(adev, size, PAGE_SIZE, ++ AMDGPU_GEM_DOMAIN_VRAM, bo_ptr, NULL, ++ cpu_addr); + if (r) + return r; + +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_object.h ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_object.h +@@ -284,7 +284,7 @@ int amdgpu_bo_create_kernel(struct amdgp + u32 domain, struct amdgpu_bo **bo_ptr, + u64 *gpu_addr, void **cpu_addr); + int amdgpu_bo_create_kernel_at(struct amdgpu_device *adev, +- uint64_t offset, uint64_t size, uint32_t domain, ++ uint64_t offset, uint64_t size, + struct amdgpu_bo **bo_ptr, void **cpu_addr); + int amdgpu_bo_create_user(struct amdgpu_device *adev, + struct amdgpu_bo_param *bp, +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c +@@ -1575,7 +1575,6 @@ static int amdgpu_ttm_fw_reserve_vram_in + return amdgpu_bo_create_kernel_at(adev, + adev->mman.fw_vram_usage_start_offset, + adev->mman.fw_vram_usage_size, +- AMDGPU_GEM_DOMAIN_VRAM, + &adev->mman.fw_vram_usage_reserved_bo, + &adev->mman.fw_vram_usage_va); + } +@@ -1600,7 +1599,6 @@ static int amdgpu_ttm_drv_reserve_vram_i + return amdgpu_bo_create_kernel_at(adev, + adev->mman.drv_vram_usage_start_offset, + adev->mman.drv_vram_usage_size, +- AMDGPU_GEM_DOMAIN_VRAM, + &adev->mman.drv_vram_usage_reserved_bo, + NULL); + } +@@ -1681,7 +1679,6 @@ static int amdgpu_ttm_reserve_tmr(struct + ret = amdgpu_bo_create_kernel_at(adev, + ctx->c2p_train_data_offset, + ctx->train_data_size, +- AMDGPU_GEM_DOMAIN_VRAM, + &ctx->c2p_bo, + NULL); + if (ret) { +@@ -1695,7 +1692,6 @@ static int amdgpu_ttm_reserve_tmr(struct + ret = amdgpu_bo_create_kernel_at(adev, + adev->gmc.real_vram_size - adev->mman.discovery_tmr_size, + adev->mman.discovery_tmr_size, +- AMDGPU_GEM_DOMAIN_VRAM, + &adev->mman.discovery_memory, + NULL); + if (ret) { +@@ -1796,21 +1792,18 @@ int amdgpu_ttm_init(struct amdgpu_device + * avoid display artifacts while transitioning between pre-OS + * and driver. */ + r = amdgpu_bo_create_kernel_at(adev, 0, adev->mman.stolen_vga_size, +- AMDGPU_GEM_DOMAIN_VRAM, + &adev->mman.stolen_vga_memory, + NULL); + if (r) + return r; + r = amdgpu_bo_create_kernel_at(adev, adev->mman.stolen_vga_size, + adev->mman.stolen_extended_size, +- AMDGPU_GEM_DOMAIN_VRAM, + &adev->mman.stolen_extended_memory, + NULL); + if (r) + return r; + r = amdgpu_bo_create_kernel_at(adev, adev->mman.stolen_reserved_offset, + adev->mman.stolen_reserved_size, +- AMDGPU_GEM_DOMAIN_VRAM, + &adev->mman.stolen_reserved_memory, + NULL); + if (r) +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_virt.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_virt.c +@@ -391,7 +391,6 @@ static void amdgpu_virt_ras_reserve_bps( + */ + if (amdgpu_bo_create_kernel_at(adev, bp << AMDGPU_GPU_PAGE_SHIFT, + AMDGPU_GPU_PAGE_SIZE, +- AMDGPU_GEM_DOMAIN_VRAM, + &bo, NULL)) + DRM_DEBUG("RAS WARN: reserve vram for retired page %llx fail\n", bp); + diff --git a/queue-6.1/drm-amdgpu-use-apt-name-for-fw-reserved-region.patch b/queue-6.1/drm-amdgpu-use-apt-name-for-fw-reserved-region.patch new file mode 100644 index 00000000000..b348b73d23d --- /dev/null +++ b/queue-6.1/drm-amdgpu-use-apt-name-for-fw-reserved-region.patch @@ -0,0 +1,130 @@ +From stable-owner@vger.kernel.org Tue Aug 8 20:31:40 2023 +From: Mario Limonciello +Date: Tue, 8 Aug 2023 12:50:55 -0500 +Subject: drm/amdgpu: Use apt name for FW reserved region +To: +Cc: Mario Limonciello +Message-ID: <20230808175055.3761-4-mario.limonciello@amd.com> + +From: Lijo Lazar + +commit db3b5cb64a9ca301d14ed027e470834316720e42 upstream + +Use the generic term fw_reserved_memory for FW reserve region. This +region may also hold discovery TMR in addition to other reserve +regions. This region size could be larger than discovery tmr size, hence +don't change the discovery tmr size based on this. + +Signed-off-by: Lijo Lazar +Reviewed-by: Le Ma +Signed-off-by: Alex Deucher +[ This change fixes reading IP discovery from debugfs. + It needed to be hand modified because: + * GC 9.4.3 support isn't introduced in older kernels until + 228ce176434b ("drm/amdgpu: Handle VRAM dependencies on GFXIP9.4.3") + * It also changed because of 58ab2c08d708 (drm/amdgpu: use VRAM|GTT + for a bunch of kernel allocations) not being present. + Link: https://gitlab.freedesktop.org/drm/amd/-/issues/2748 ] +Signed-off-by: Mario Limonciello +Signed-off-by: Greg Kroah-Hartman +--- + drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c | 33 ++++++++++++++++++-------------- + drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h | 3 +- + 2 files changed, 21 insertions(+), 15 deletions(-) + +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c +@@ -1625,14 +1625,15 @@ static int amdgpu_ttm_training_reserve_v + return 0; + } + +-static void amdgpu_ttm_training_data_block_init(struct amdgpu_device *adev) ++static void amdgpu_ttm_training_data_block_init(struct amdgpu_device *adev, ++ uint32_t reserve_size) + { + struct psp_memory_training_context *ctx = &adev->psp.mem_train_ctx; + + memset(ctx, 0, sizeof(*ctx)); + + ctx->c2p_train_data_offset = +- ALIGN((adev->gmc.mc_vram_size - adev->mman.discovery_tmr_size - SZ_1M), SZ_1M); ++ ALIGN((adev->gmc.mc_vram_size - reserve_size - SZ_1M), SZ_1M); + ctx->p2c_train_data_offset = + (adev->gmc.mc_vram_size - GDDR6_MEM_TRAINING_OFFSET); + ctx->train_data_size = +@@ -1650,9 +1651,10 @@ static void amdgpu_ttm_training_data_blo + */ + static int amdgpu_ttm_reserve_tmr(struct amdgpu_device *adev) + { +- int ret; + struct psp_memory_training_context *ctx = &adev->psp.mem_train_ctx; + bool mem_train_support = false; ++ uint32_t reserve_size = 0; ++ int ret; + + if (!amdgpu_sriov_vf(adev)) { + if (amdgpu_atomfirmware_mem_training_supported(adev)) +@@ -1668,14 +1670,15 @@ static int amdgpu_ttm_reserve_tmr(struct + * Otherwise, fallback to legacy approach to check and reserve tmr block for ip + * discovery data and G6 memory training data respectively + */ +- adev->mman.discovery_tmr_size = +- amdgpu_atomfirmware_get_fw_reserved_fb_size(adev); +- if (!adev->mman.discovery_tmr_size) +- adev->mman.discovery_tmr_size = DISCOVERY_TMR_OFFSET; ++ if (adev->bios) ++ reserve_size = ++ amdgpu_atomfirmware_get_fw_reserved_fb_size(adev); ++ if (!reserve_size) ++ reserve_size = DISCOVERY_TMR_OFFSET; + + if (mem_train_support) { + /* reserve vram for mem train according to TMR location */ +- amdgpu_ttm_training_data_block_init(adev); ++ amdgpu_ttm_training_data_block_init(adev, reserve_size); + ret = amdgpu_bo_create_kernel_at(adev, + ctx->c2p_train_data_offset, + ctx->train_data_size, +@@ -1690,13 +1693,14 @@ static int amdgpu_ttm_reserve_tmr(struct + } + + ret = amdgpu_bo_create_kernel_at(adev, +- adev->gmc.real_vram_size - adev->mman.discovery_tmr_size, +- adev->mman.discovery_tmr_size, +- &adev->mman.discovery_memory, ++ adev->gmc.real_vram_size - reserve_size, ++ reserve_size, ++ &adev->mman.fw_reserved_memory, + NULL); + if (ret) { + DRM_ERROR("alloc tmr failed(%d)!\n", ret); +- amdgpu_bo_free_kernel(&adev->mman.discovery_memory, NULL, NULL); ++ amdgpu_bo_free_kernel(&adev->mman.fw_reserved_memory, ++ NULL, NULL); + return ret; + } + +@@ -1890,8 +1894,9 @@ void amdgpu_ttm_fini(struct amdgpu_devic + /* return the stolen vga memory back to VRAM */ + amdgpu_bo_free_kernel(&adev->mman.stolen_vga_memory, NULL, NULL); + amdgpu_bo_free_kernel(&adev->mman.stolen_extended_memory, NULL, NULL); +- /* return the IP Discovery TMR memory back to VRAM */ +- amdgpu_bo_free_kernel(&adev->mman.discovery_memory, NULL, NULL); ++ /* return the FW reserved memory back to VRAM */ ++ amdgpu_bo_free_kernel(&adev->mman.fw_reserved_memory, NULL, ++ NULL); + if (adev->mman.stolen_reserved_size) + amdgpu_bo_free_kernel(&adev->mman.stolen_reserved_memory, + NULL, NULL); +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.h +@@ -78,7 +78,8 @@ struct amdgpu_mman { + /* discovery */ + uint8_t *discovery_bin; + uint32_t discovery_tmr_size; +- struct amdgpu_bo *discovery_memory; ++ /* fw reserved memory */ ++ struct amdgpu_bo *fw_reserved_memory; + + /* firmware VRAM reservation */ + u64 fw_vram_usage_start_offset; diff --git a/queue-6.1/series b/queue-6.1/series index 3e208dd0fea..b70f1144dec 100644 --- a/queue-6.1/series +++ b/queue-6.1/series @@ -121,3 +121,6 @@ f2fs-fix-to-set-flush_merge-opt-and-show-noflush_mer.patch f2fs-don-t-reset-unchangable-mount-option-in-f2fs_re.patch exfat-check-if-filename-entries-exceeds-max-filename.patch arm64-ptrace-don-t-enable-sve-when-setting-streaming-sve.patch +drm-amdgpu-add-vram-reservation-based-on-vram_usagebyfirmware_v2_2.patch +drm-amdgpu-remove-unnecessary-domain-argument.patch +drm-amdgpu-use-apt-name-for-fw-reserved-region.patch