drm/amdgpu/gfx6: Support harvested SI chips with disabled TCCs (v2)

This commit fixes amdgpu to work on the Radeon HD 7870 XT
which has never worked with the Linux open source drivers before.

Some boards have "harvested" chips, meaning that some parts of
the chip are disabled and fused, and it's sold for cheaper and
under a different marketing name.
On a harvested chip, any of the following can be disabled:
- CUs (Compute Units)
- RBs (Render Backend, aka. ROP)
- Memory channels (ie. the chip has a lower bandwidth)
- TCCs (ie. less L2 cache)

Handle chips with harvested TCCs by patching the registers
that configure how TCCs are mapped.

If some TCCs are disabled, we need to make sure that
the disabled TCCs are not used, and the remaining TCCs
are used optimally.

TCP_CHAN_STEER_LO/HI control which TCC is used by TCP channels.
TCP_ADDR_CONFIG.NUM_TCC_BANKS controls how many channels are used.

Note that the TCC configuration is highly relevant to performance.
Suboptimal configuration (eg. CHAN_STEER=0) can significantly
reduce gaming performance.

For optimal performance:
- Rely on the CHAN_STEER from the golden registers table,
  only skip disabled TCCs but keep the mapping order.
- Limit NUM_TCC_BANKS to number of active TCCs to avoid thrashing,
  which performs better than using the same TCC twice.

v2:
- Also consider CGTS_USER_TCC_DISABLE for disabled TCCs.

Link: https://bugs.freedesktop.org/show_bug.cgi?id=60879
Closes: https://gitlab.freedesktop.org/drm/amd/-/work_items/2664
Fixes: 2cd46ad22383 ("drm/amdgpu: add graphic pipeline implementation for si v8")
Signed-off-by: Timur Kristóf <timur.kristof@gmail.com>
Reviewed-by: Christian König <christian.koenig@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
(cherry picked from commit 00218d15528fab9f6b31241fe5904eea4fcaa30d)

diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v6_0.c b/drivers/gpu/drm/amd/amdgpu/gfx_v6_0.c
index 73223d97a87f59247c9084298b0fc48935590ab9..ac90d8e9d86a83ded1085f7b513db3901106fe6f 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/gfx_v6_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/gfx_v6_0.c
@@ -1571,6 +1571,71 @@ static void gfx_v6_0_setup_spi(struct amdgpu_device *adev)
        mutex_unlock(&adev->grbm_idx_mutex);
 }
 
+/**
+ * gfx_v6_0_setup_tcc() - setup which TCCs are used
+ *
+ * @adev: amdgpu_device pointer
+ *
+ * Verify whether the current GPU has any TCCs disabled,
+ * which can happen when the GPU is harvested and some
+ * memory channels are disabled, reducing the memory bus width.
+ * For example, on the Radeon HD 7870 XT (Tahiti LE).
+ *
+ * If some TCCs are disabled, we need to make sure that
+ * the disabled TCCs are not used, and the remaining TCCs
+ * are used optimally.
+ *
+ * TCP_CHAN_STEER_LO/HI control which TCC is used by TCP channels.
+ * TCP_ADDR_CONFIG.NUM_TCC_BANKS controls how many channels are used.
+ *
+ * For optimal performance:
+ * - Rely on the CHAN_STEER from the golden registers table,
+ *   only skip disabled TCCs but keep the mapping order.
+ * - Limit NUM_TCC_BANKS to number of active TCCs to avoid thrashing,
+ *   which performs better than using the same TCC twice.
+ */
+static void gfx_v6_0_setup_tcc(struct amdgpu_device *adev)
+{
+       u32 i, tcc, tcp_addr_config, num_active_tcc = 0;
+       u64 chan_steer, patched_chan_steer = 0;
+       const u32 num_max_tcc = adev->gfx.config.max_texture_channel_caches;
+       const u32 dis_tcc_mask =
+               amdgpu_gfx_create_bitmask(num_max_tcc) &
+               (REG_GET_FIELD(RREG32(mmCGTS_TCC_DISABLE),
+                              CGTS_TCC_DISABLE, TCC_DISABLE) |
+                REG_GET_FIELD(RREG32(mmCGTS_USER_TCC_DISABLE),
+                              CGTS_USER_TCC_DISABLE, TCC_DISABLE));
+
+       /* When no TCC is disabled, the golden registers table already has optimal TCC setup */
+       if (!dis_tcc_mask)
+               return;
+
+       /* Each 4-bit nibble contains the index of a TCC used by all TCPs */
+       chan_steer = RREG32(mmTCP_CHAN_STEER_LO) | ((u64)RREG32(mmTCP_CHAN_STEER_HI) << 32ull);
+
+       /* Patch the TCP to TCC mapping to skip disabled TCCs */
+       for (i = 0; i < num_max_tcc; ++i) {
+               tcc = (chan_steer >> (u64)(4 * i)) & 0xf;
+
+               if (!((1 << tcc) & dis_tcc_mask)) {
+                       /* Copy enabled TCC indices to the patched register value. */
+                       patched_chan_steer |= (u64)tcc << (u64)(4 * num_active_tcc);
+                       ++num_active_tcc;
+               }
+       }
+
+       WARN_ON(num_active_tcc != num_max_tcc - hweight32(dis_tcc_mask));
+
+       /* Patch number of TCCs used by TCPs */
+       tcp_addr_config = REG_SET_FIELD(RREG32(mmTCP_ADDR_CONFIG),
+                                       TCP_ADDR_CONFIG, NUM_TCC_BANKS,
+                                       num_active_tcc - 1);
+
+       WREG32(mmTCP_ADDR_CONFIG, tcp_addr_config);
+       WREG32(mmTCP_CHAN_STEER_HI, upper_32_bits(patched_chan_steer));
+       WREG32(mmTCP_CHAN_STEER_LO, lower_32_bits(patched_chan_steer));
+}
+
 static void gfx_v6_0_config_init(struct amdgpu_device *adev)
 {
        adev->gfx.config.double_offchip_lds_buf = 0;
@@ -1729,6 +1794,7 @@ static void gfx_v6_0_constants_init(struct amdgpu_device *adev)
        gfx_v6_0_tiling_mode_table_init(adev);
 
        gfx_v6_0_setup_rb(adev);
+       gfx_v6_0_setup_tcc(adev);
 
        gfx_v6_0_setup_spi(adev);