--- /dev/null
+From stable-owner@vger.kernel.org Tue Aug 8 20:31:40 2023
+From: Mario Limonciello <mario.limonciello@amd.com>
+Date: Tue, 8 Aug 2023 12:50:53 -0500
+Subject: drm/amdgpu: add vram reservation based on vram_usagebyfirmware_v2_2
+To: <stable@vger.kernel.org>
+Cc: Mario Limonciello <mario.limonciello@amd.com>
+Message-ID: <20230808175055.3761-2-mario.limonciello@amd.com>
+
+From: Tong Liu01 <Tong.Liu01@amd.com>
+
+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 <Tong.Liu01@amd.com>
+Acked-by: Christian König <christian.koenig@amd.com>
+Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
+Signed-off-by: Mario Limonciello <mario.limonciello@amd.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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];
++};
+
+ /*
+ ***************************************************************************
--- /dev/null
+From stable-owner@vger.kernel.org Tue Aug 8 20:31:33 2023
+From: Mario Limonciello <mario.limonciello@amd.com>
+Date: Tue, 8 Aug 2023 12:50:54 -0500
+Subject: drm/amdgpu: Remove unnecessary domain argument
+To: <stable@vger.kernel.org>
+Cc: Mario Limonciello <mario.limonciello@amd.com>
+Message-ID: <20230808175055.3761-3-mario.limonciello@amd.com>
+
+From: Luben Tuikov <luben.tuikov@amd.com>
+
+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 <Alexander.Deucher@amd.com>
+Cc: Christian König <christian.koenig@amd.com>
+Cc: AMD Graphics <amd-gfx@lists.freedesktop.org>
+Signed-off-by: Luben Tuikov <luben.tuikov@amd.com>
+Reviewed-by: Christian König <christian.koenig@amd.com>
+Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
+Signed-off-by: Mario Limonciello <mario.limonciello@amd.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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);
+
--- /dev/null
+From stable-owner@vger.kernel.org Tue Aug 8 20:31:40 2023
+From: Mario Limonciello <mario.limonciello@amd.com>
+Date: Tue, 8 Aug 2023 12:50:55 -0500
+Subject: drm/amdgpu: Use apt name for FW reserved region
+To: <stable@vger.kernel.org>
+Cc: Mario Limonciello <mario.limonciello@amd.com>
+Message-ID: <20230808175055.3761-4-mario.limonciello@amd.com>
+
+From: Lijo Lazar <lijo.lazar@amd.com>
+
+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 <lijo.lazar@amd.com>
+Reviewed-by: Le Ma <le.ma@amd.com>
+Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
+[ 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 <mario.limonciello@amd.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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;
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
projects / thirdparty / kernel / stable-queue.git / commitdiff
