fixup! drm/asahi: Add the Asahi driver for Apple AGX GPUs

Signed-off-by: Janne Grunau <j@jannau.net>

Author: jannau

drivers/gpu/drm/asahi/alloc.rs

@@ -627,7 +627,7 @@ impl Drop for HeapAllocation {
 
         alloc.with(|a| {
             if let Some(garbage) = a.garbage.as_mut() {
-                if garbage.try_push(node).is_err() {
+                if garbage.push(node, GFP_KERNEL).is_err() {
                     dev_err!(
                         &a.dev,
                         "HeapAllocation[{}]::drop: Failed to keep garbage\n",
@@ -825,7 +825,7 @@ impl HeapAllocator {
             })?;
 
         self.mm
-            .with_inner(|inner| inner.backing_objects.try_reserve(1))?;
+            .with_inner(|inner| inner.backing_objects.reserve(1, GFP_KERNEL))?;
 
         let mut new_top = self.top + size_aligned as u64;
         if self.cpu_maps {
@@ -859,7 +859,7 @@ impl HeapAllocator {
                 }
             };
 
-            self.guard_nodes.try_push(node)?;
+            self.guard_nodes.push(node, GFP_KERNEL)?;
 
             new_top += guard as u64;
         }

drivers/gpu/drm/asahi/buffer.rs

@@ -411,26 +411,29 @@ impl Buffer::ver {
             })?;
 
         Ok(Buffer::ver {
-            inner: Arc::pin_init(Mutex::new(BufferInner::ver {
-                info,
-                ualloc,
-                ualloc_priv,
-                blocks: Vec::new(),
-                max_blocks,
-                max_blocks_nomemless,
-                mgr: mgr.clone(),
-                active_scenes: 0,
-                active_slot: None,
-                last_token: None,
-                tpc: None,
-                kernel_buffer,
-                stats,
-                cfg: gpu.get_cfg(),
-                preempt1_size,
-                preempt2_size,
-                preempt3_size,
-                num_clusters,
-            }))?,
+            inner: Arc::pin_init(
+                Mutex::new(BufferInner::ver {
+                    info,
+                    ualloc,
+                    ualloc_priv,
+                    blocks: Vec::new(),
+                    max_blocks,
+                    max_blocks_nomemless,
+                    mgr: mgr.clone(),
+                    active_scenes: 0,
+                    active_slot: None,
+                    last_token: None,
+                    tpc: None,
+                    kernel_buffer,
+                    stats,
+                    cfg: gpu.get_cfg(),
+                    preempt1_size,
+                    preempt2_size,
+                    preempt3_size,
+                    num_clusters,
+                }),
+                GFP_KERNEL,
+            )?,
         })
     }
 
@@ -500,20 +503,20 @@ impl Buffer::ver {
         // Allocate the new blocks first, so if it fails they will be dropped
         let mut ualloc = inner.ualloc.lock();
         for _i in 0..add_blocks {
-            new_blocks.try_push(ualloc.array_gpuonly(BLOCK_SIZE)?)?;
+            new_blocks.push(ualloc.array_gpuonly(BLOCK_SIZE)?, GFP_KERNEL)?;
         }
         core::mem::drop(ualloc);
 
         // Then actually commit them
-        inner.blocks.try_reserve(add_blocks)?;
+        inner.blocks.reserve(add_blocks, GFP_KERNEL)?;
 
         for (i, block) in new_blocks.into_iter().enumerate() {
             let page_num = (block.gpu_va().get() >> PAGE_SHIFT) as u32;
 
             inner
                 .blocks
-                .try_push(block)
-                .expect("try_push() failed after try_reserve()");
+                .push(block, GFP_KERNEL)
+                .expect("push() failed after reserve()");
             inner.info.block_list[2 * (cur_count + i)] = page_num;
             for j in 0..PAGES_PER_BLOCK {
                 inner.info.page_list[(cur_count + i) * PAGES_PER_BLOCK + j] = page_num + j as u32;
@@ -762,7 +765,7 @@ impl BufferManager::ver {
     pub(crate) fn new() -> Result<BufferManager::ver> {
         let mut owners = Vec::new();
         for _i in 0..(NUM_BUFFERS as usize) {
-            owners.try_push(None)?;
+            owners.push(None, GFP_KERNEL)?;
         }
         Ok(BufferManager::ver(slotalloc::SlotAllocator::new(
             NUM_BUFFERS,

drivers/gpu/drm/asahi/event.rs

@@ -142,7 +142,7 @@ impl EventManager {
     pub(crate) fn new(alloc: &mut gpu::KernelAllocators) -> Result<EventManager> {
         let mut owners = Vec::new();
         for _i in 0..(NUM_EVENTS as usize) {
-            owners.try_push(None)?;
+            owners.push(None, GFP_KERNEL)?;
         }
         let inner = EventManagerInner {
             stamps: alloc.shared.array_empty(NUM_EVENTS as usize)?,
@@ -222,7 +222,7 @@ impl EventManager {
 
         self.alloc.with_inner(|inner| {
             for wq in inner.owners.iter().filter_map(|o| o.as_ref()).cloned() {
-                if owners.try_push(wq).is_err() {
+                if owners.push(wq, GFP_KERNEL).is_err() {
                     pr_err!("Failed to signal failure to WorkQueue\n");
                 }
             }

drivers/gpu/drm/asahi/file.rs

@@ -119,7 +119,7 @@ impl SyncItem {
     }
 
     fn parse_array(file: &DrmFile, ptr: u64, count: u32, out: bool) -> Result<Vec<SyncItem>> {
-        let mut vec = Vec::try_with_capacity(count as usize)?;
+        let mut vec = Vec::with_capacity(count as usize, GFP_KERNEL)?;
 
         const STRIDE: usize = core::mem::size_of::<uapi::drm_asahi_sync>();
         let size = STRIDE * count as usize;
@@ -136,7 +136,7 @@ impl SyncItem {
             // SAFETY: All bit patterns in the struct are valid
             let sync = unsafe { sync.assume_init() };
 
-            vec.try_push(SyncItem::parse_one(file, sync, out)?)?;
+            vec.push(SyncItem::parse_one(file, sync, out)?, GFP_KERNEL)?;
         }
 
         Ok(vec)
@@ -182,11 +182,14 @@ impl drm::file::DriverFile for File {
         let id = gpu.ids().file.next();
 
         mod_dev_dbg!(device, "[File {}]: DRM device opened\n", id);
-        Ok(Box::into_pin(Box::try_new(Self {
-            id,
-            vms: xarray::XArray::new(xarray::flags::ALLOC1),
-            queues: xarray::XArray::new(xarray::flags::ALLOC1),
-        })?))
+        Ok(Box::into_pin(Box::new(
+            Self {
+                id,
+                vms: xarray::XArray::new(xarray::flags::ALLOC1),
+                queues: xarray::XArray::new(xarray::flags::ALLOC1),
+            },
+            GFP_KERNEL,
+        )?))
     }
 }
 
@@ -688,7 +691,7 @@ impl File {
                 .new_queue(vm, ualloc, ualloc_priv, data.priority, data.queue_caps)?;
 
         data.queue_id = resv.index().try_into()?;
-        resv.store(Arc::pin_init(Mutex::new(queue))?)?;
+        resv.store(Arc::pin_init(Mutex::new(queue), GFP_KERNEL)?)?;
 
         Ok(0)
     }
@@ -802,7 +805,7 @@ impl File {
             data.queue_id,
             id
         );
-        let mut commands = Vec::try_with_capacity(data.command_count as usize)?;
+        let mut commands = Vec::with_capacity(data.command_count as usize, GFP_KERNEL)?;
 
         const STRIDE: usize = core::mem::size_of::<uapi::drm_asahi_command>();
         let size = STRIDE * data.command_count as usize;
@@ -818,7 +821,7 @@ impl File {
             unsafe { reader.read_raw(cmd.as_mut_ptr() as *mut u8, STRIDE)? };
 
             // SAFETY: All bit patterns in the struct are valid
-            commands.try_push(unsafe { cmd.assume_init() })?;
+            commands.push(unsafe { cmd.assume_init() }, GFP_KERNEL)?;
         }
 
         let ret = queue

drivers/gpu/drm/asahi/gpu.rs

@@ -490,11 +490,14 @@ impl GpuManager::ver {
             .zip(&mgr.pipes.frag)
             .zip(&mgr.pipes.comp)
         {
-            p_pipes.try_push(fw::initdata::raw::PipeChannels::ver {
-                vtx: v.lock().to_raw(),
-                frag: f.lock().to_raw(),
-                comp: c.lock().to_raw(),
-            })?;
+            p_pipes.push(
+                fw::initdata::raw::PipeChannels::ver {
+                    vtx: v.lock().to_raw(),
+                    frag: f.lock().to_raw(),
+                    comp: c.lock().to_raw(),
+                },
+                GFP_KERNEL,
+            )?;
         }
 
         mgr.as_mut()
@@ -532,7 +535,7 @@ impl GpuManager::ver {
                     raw.sgx_sram_ptr = U64(mapping.iova());
                 });
 
-            mgr.as_mut().io_mappings_mut().try_push(mapping)?;
+            mgr.as_mut().io_mappings_mut().push(mapping, GFP_KERNEL)?;
         }
 
         let mgr = Arc::from(mgr);
@@ -601,7 +604,10 @@ impl GpuManager::ver {
         #[ver(G < G14X)]
         let map_kernel_to_user = false;
 
-        Ok(Box::try_new(mmu::Uat::new(dev, cfg, map_kernel_to_user)?)?)
+        Ok(Box::new(
+            mmu::Uat::new(dev, cfg, map_kernel_to_user)?,
+            GFP_KERNEL,
+        )?)
     }
 
     /// Actually create the final GpuManager instance, as a UniqueArc.
@@ -624,18 +630,36 @@ impl GpuManager::ver {
         };
 
         for _i in 0..=NUM_PIPES - 1 {
-            pipes.vtx.try_push(Box::pin_init(Mutex::new_named(
-                channel::PipeChannel::ver::new(dev, &mut alloc)?,
-                c_str!("pipe_vtx"),
-            ))?)?;
-            pipes.frag.try_push(Box::pin_init(Mutex::new_named(
-                channel::PipeChannel::ver::new(dev, &mut alloc)?,
-                c_str!("pipe_frag"),
-            ))?)?;
-            pipes.comp.try_push(Box::pin_init(Mutex::new_named(
-                channel::PipeChannel::ver::new(dev, &mut alloc)?,
-                c_str!("pipe_comp"),
-            ))?)?;
+            pipes.vtx.push(
+                Box::pin_init(
+                    Mutex::new_named(
+                        channel::PipeChannel::ver::new(dev, &mut alloc)?,
+                        c_str!("pipe_vtx"),
+                    ),
+                    GFP_KERNEL,
+                )?,
+                GFP_KERNEL,
+            )?;
+            pipes.frag.push(
+                Box::pin_init(
+                    Mutex::new_named(
+                        channel::PipeChannel::ver::new(dev, &mut alloc)?,
+                        c_str!("pipe_frag"),
+                    ),
+                    GFP_KERNEL,
+                )?,
+                GFP_KERNEL,
+            )?;
+            pipes.comp.push(
+                Box::pin_init(
+                    Mutex::new_named(
+                        channel::PipeChannel::ver::new(dev, &mut alloc)?,
+                        c_str!("pipe_comp"),
+                    ),
+                    GFP_KERNEL,
+                )?,
+                GFP_KERNEL,
+            )?;
         }
 
         let fwctl_channel = channel::FwCtlChannel::new(dev, &mut alloc)?;
@@ -1182,18 +1206,21 @@ impl GpuManager for GpuManager::ver {
     ) -> Result<Box<dyn queue::Queue>> {
         let mut kalloc = self.alloc();
         let id = self.ids.queue.next();
-        Ok(Box::try_new(queue::Queue::ver::new(
-            &self.dev,
-            vm,
-            &mut kalloc,
-            ualloc,
-            ualloc_priv,
-            self.event_manager.clone(),
-            &self.buffer_mgr,
-            id,
-            priority,
-            caps,
-        )?)?)
+        Ok(Box::new(
+            queue::Queue::ver::new(
+                &self.dev,
+                vm,
+                &mut kalloc,
+                ualloc,
+                ualloc_priv,
+                self.event_manager.clone(),
+                &self.buffer_mgr,
+                id,
+                priority,
+                caps,
+            )?,
+            GFP_KERNEL,
+        )?)
     }
 
     fn kick_firmware(&self) -> Result {
@@ -1357,7 +1384,7 @@ impl GpuManager for GpuManager::ver {
     fn add_completed_work(&self, work: Vec<Box<dyn workqueue::GenSubmittedWork>>) {
         let mut garbage = self.garbage_work.lock();
 
-        if garbage.try_reserve(work.len()).is_err() {
+        if garbage.reserve(work.len(), GFP_KERNEL).is_err() {
             dev_err!(
                 self.dev,
                 "Failed to reserve space for completed work, deadlock possible.\n"
@@ -1367,15 +1394,15 @@ impl GpuManager for GpuManager::ver {
 
         for i in work {
             garbage
-                .try_push(i)
-                .expect("try_push() failed after try_reserve()");
+                .push(i, GFP_KERNEL)
+                .expect("push() failed after reserve()");
         }
     }
 
     fn free_context(&self, ctx: Box<fw::types::GpuObject<fw::workqueue::GpuContextData>>) {
         let mut garbage = self.garbage_contexts.lock();
 
-        if garbage.try_push(ctx).is_err() {
+        if garbage.push(ctx, GFP_KERNEL).is_err() {
             dev_err!(
                 self.dev,
                 "Failed to reserve space for freed context, deadlock possible.\n"

drivers/gpu/drm/asahi/hw/mod.rs

@@ -514,11 +514,14 @@ impl PwrConfig {
 
             let pwr_mw = pwr_uw / 1000;
 
-            perf_states.try_push(PState {
-                freq_hz: freq_hz.try_into()?,
-                volt_mv,
-                pwr_mw,
-            })?;
+            perf_states.push(
+                PState {
+                    freq_hz: freq_hz.try_into()?,
+                    volt_mv,
+                    pwr_mw,
+                },
+                GFP_KERNEL,
+            )?;
         }
 
         if perf_states.is_empty() {
@@ -560,11 +563,14 @@ impl PwrConfig {
         let pz_count = pz_data.len() / 3;
         let mut power_zones = Vec::new();
         for i in (0..pz_count).step_by(3) {
-            power_zones.try_push(PowerZone {
-                target: pz_data[i],
-                target_offset: pz_data[i + 1],
-                filter_tc: pz_data[i + 2],
-            })?;
+            power_zones.push(
+                PowerZone {
+                    target: pz_data[i],
+                    target_offset: pz_data[i + 1],
+                    filter_tc: pz_data[i + 2],
+                },
+                GFP_KERNEL,
+            )?;
         }
 
         let core_leak_coef: Vec<F32> = prop!("apple,core-leak-coef");