drm/asahi: Identify and allocate clustered layering metadata buf

Turns out multi-cluster machines also need a clustered buffer for
layered rendering.

Fixes layered rendering on G13X with barriers (I guess if you don't
flush memory this stays in some kind of cache and somehow doesn't
matter?).

Signed-off-by: Asahi Lina <lina@asahilina.net>

Author: hoshinolina

drivers/gpu/drm/asahi/buffer.rs

@@ -111,6 +111,8 @@ pub(crate) struct Scene {
     // Note: these are dead code only on some version variants.
     // It's easier to do this than to propagate the version conditionals everywhere.
     #[allow(dead_code)]
+    meta1_off: usize,
+    #[allow(dead_code)]
     meta2_off: usize,
     #[allow(dead_code)]
     meta3_off: usize,
@@ -208,13 +210,22 @@ impl Scene::ver {
             .map(|c| c.tilemaps.gpu_pointer())
     }
 
+    /// Returns the GPU pointer to the clustering layer metadata buffer, if clustering is enabled.
+    #[allow(dead_code)]
+    pub(crate) fn tvb_cluster_layermeta_pointer(&self) -> Option<GpuPointer<'_, &'_ [u8]>> {
+        self.object
+            .clustering
+            .as_ref()
+            .map(|c| c.meta.gpu_pointer())
+    }
+
     /// Returns the GPU pointer to the clustering metadata 1 buffer, if clustering is enabled.
     #[allow(dead_code)]
     pub(crate) fn meta_1_pointer(&self) -> Option<GpuPointer<'_, &'_ [u8]>> {
         self.object
             .clustering
             .as_ref()
-            .map(|c| c.meta.gpu_pointer())
+            .map(|c| c.meta.gpu_offset_pointer(self.meta1_off))
     }
 
     /// Returns the GPU pointer to the clustering metadata 2 buffer, if clustering is enabled.
@@ -585,21 +596,23 @@ impl Buffer::ver {
             }
         };
 
+        let mut clmeta_size = 0;
         let mut meta1_size = 0;
         let mut meta2_size = 0;
         let mut meta3_size = 0;
 
         let clustering = if inner.num_clusters > 1 {
             let cfg = inner.cfg.clustering.as_ref().unwrap();
 
+            clmeta_size = tile_info.layermeta_size * cfg.max_splits;
             // Maybe: (4x4 macro tiles + 1 global page)*n, 32bit each (17*4*n)
             // Unused on t602x?
             meta1_size = align(tile_info.meta1_blocks as usize * cfg.meta1_blocksize, 0x80);
             meta2_size = align(cfg.meta2_size, 0x80);
             meta3_size = align(cfg.meta3_size, 0x80);
             let meta4_size = cfg.meta4_size;
 
-            let meta_size = meta1_size + meta2_size + meta3_size + meta4_size;
+            let meta_size = clmeta_size + meta1_size + meta2_size + meta3_size + meta4_size;
 
             mod_pr_debug!("Buffer: Allocating clustering buffers\n");
             let tilemaps = inner
@@ -685,9 +698,10 @@ impl Buffer::ver {
             rebind,
             preempt2_off: inner.preempt1_size,
             preempt3_off: inner.preempt1_size + inner.preempt2_size,
-            meta2_off: meta1_size,
-            meta3_off: meta1_size + meta2_size,
-            meta4_off: meta1_size + meta2_size + meta3_size,
+            meta1_off: clmeta_size,
+            meta2_off: clmeta_size + meta1_size,
+            meta3_off: clmeta_size + meta1_size + meta2_size,
+            meta4_off: clmeta_size + meta1_size + meta2_size + meta3_size,
         })
     }
 

drivers/gpu/drm/asahi/fw/vertex.rs

@@ -49,7 +49,7 @@ pub(crate) mod raw {
         pub(crate) ppp_multisamplectl: U64,
         pub(crate) tvb_layermeta: GpuPointer<'a, &'a [u8]>,
         #[ver(G < G14)]
-        pub(crate) unk_60: U64,
+        pub(crate) tvb_cluster_layermeta: Option<GpuPointer<'a, &'a [u8]>>,
         #[ver(G < G14)]
         pub(crate) core_mask: Array<2, u32>,
         pub(crate) preempt_buf1: GpuPointer<'a, &'a [u8]>,

drivers/gpu/drm/asahi/queue/render.rs

@@ -1307,7 +1307,7 @@ impl super::Queue::ver {
                         ppp_multisamplectl: U64(cmdbuf.ppp_multisamplectl), // fixed
                         tvb_layermeta: inner.scene.tvb_layermeta_pointer(),
                         #[ver(G < G14)]
-                        unk_60: U64(0x0), // fixed
+                        tvb_cluster_layermeta: inner.scene.tvb_cluster_layermeta_pointer(),
                         #[ver(G < G14)]
                         core_mask: Array::new([
                             *core_masks.first().unwrap_or(&0),
@@ -1400,8 +1400,10 @@ impl super::Queue::ver {
                             r.add(0x1c918, unks.tiling_control_2);
                             r.add(0x1c079, inner.scene.tvb_layermeta_pointer().into());
                             r.add(0x1c9d8, inner.scene.tvb_layermeta_pointer().into());
-                            r.add(0x1c089, 0);
-                            r.add(0x1c9e0, 0);
+                            let cl_layermeta_pointer =
+                                inner.scene.tvb_cluster_layermeta_pointer().map_or(0, |a| a.into());
+                            r.add(0x1c089, cl_layermeta_pointer);
+                            r.add(0x1c9e0, cl_layermeta_pointer);
                             let cl_meta_4_pointer =
                                 inner.scene.meta_4_pointer().map_or(0, |a| a.into());
                             r.add(0x16c41, cl_meta_4_pointer); // tvb_cluster_meta4