STRUCT PANTHOR_QUEUE(9)

💖 NAME 💖

struct panthor_queue — Execution queue. Yes bestie, this page is the struct panthor_queue(9) entry from the Kernel API Manual, and we are about to go through every member like it’s a group-chat receipt 💅✨

---

✨ SYNOPSIS ✨

       struct panthor_queue {
           struct drm_gpu_scheduler scheduler;
           struct drm_sched_entity entity;
           char *name;
           struct {
             struct delayed_work work;
             unsigned long remaining;
           } timeout;
           u8 doorbell_id;
           u8 priority;
         #define CSF_MAX_QUEUE_PRIO      GENMASK(3, 0);
           struct panthor_kernel_bo *ringbuf;
           struct {
             struct panthor_kernel_bo *mem;
             struct panthor_fw_ringbuf_input_iface *input;
             const struct panthor_fw_ringbuf_output_iface *output;
             u32 input_fw_va;
             u32 output_fw_va;
           } iface;
           struct {
             u64 gpu_va;
             u64 ref;
             bool gt;
             bool sync64;
             struct drm_gem_object *obj;
             u64 offset;
             void *kmap;
           } syncwait;
           struct {
             spinlock_t lock;
             u64 id;
             atomic64_t seqno;
             struct dma_fence *last_fence;
             struct list_head in_flight_jobs;
           } fence_ctx;
           struct {
             struct panthor_kernel_bo *slots;
             u32 slot_count;
             u32 seqno;
           } profiling;
        };

---

🎀 Members 🎀

• scheduler — the DRM scheduler used for this queue. Main character of the scheduling situation.
• entity — the DRM scheduling entity used for this queue.
• name — the DRM scheduler name for this queue. It’s giving name tag energy.
• timeout — queue timeout related fields, bestie.
  • timeout.work — the work executed when a queue timeout occurs.
  • timeout.remaining — time remaining before a queue timeout.

When the timer is running, timeout.remaining is set to MAX_SCHEDULE_TIMEOUT. When the timer is suspended, it’s set to the time remaining when the timer was suspended.

• doorbell_id — the doorbell assigned to this queue.

Right now, all groups share the same doorbell, and the doorbell ID is assigned to group_slot + 1 when the group is assigned a slot. But we might decide to provide fine grained doorbell assignment at some point, so we don’t have to wake up all queues in a group every time one of them is updated.

• priority — the priority of the queue inside the group.

Must be less than 16 — only 4 bits available, periodt.

• ringbuf — the command stream ring-buffer.
• iface — firmware interface. The whole FW communication situation.
  • iface.mem — FW memory allocated for this interface.
  • iface.input — input interface.
  • iface.output — output interface.
  • iface.input_fw_va — FW virtual address of the input interface buffer.
  • iface.output_fw_va — FW virtual address of the output interface buffer.
• syncwait — stores information about the synchronization object this queue is waiting on.
  • syncwait.gpu_va — GPU address of the synchronization object.
  • syncwait.ref — reference value to compare against.
  • syncwait.gt — true if this is a greater-than test.
  • syncwait.sync64 — true if this is a 64-bit sync object.
  • syncwait.obj — buffer object holding the synchronization object.
  • syncwait.offset — offset of the synchronization object inside bo.
  • syncwait.kmap — kernel mapping of the buffer object holding the synchronization object.
• fence_ctx — fence context fields, aka the fence lore.
  • fence_ctx.lock — used to protect access to all fences allocated by this context.
  • fence_ctx.id — fence context ID. Allocated with dma_fence_context_alloc.
  • fence_ctx.seqno — sequence number of the last initialized fence.
  • fence_ctx.last_fence — fence of the last submitted job.

We return this fence when we get an empty command stream. This way, we are guaranteed that all earlier jobs have completed when drm_sched_job::s_fence::finished without having to feed the CS ring buffer with a dummy job that only signals the fence.

• fence_ctx.in_flight_jobs — list containing all in-flight jobs.

Used to keep track and signal panthor_job::done_fence when the synchronization object attached to the queue is signaled.

• profiling — job profiling data slots and access information.
  • profiling.slots — kernel BO holding the slots.
  • profiling.slot_count — number of jobs ringbuffer can hold at once.
  • profiling.seqno — index of the next available profiling information slot.

---

🌈 SEE ALSO 🌈

• Kernel file ./drivers/gpu/drm/panthor/panthor_sched.c — the source file for all this scheduler magic.
• Scheduler(9)
• struct panthor_csg_slot(9)
• enum panthor_csg_priority(9)
• struct panthor_scheduler(9)
• struct panthor_syncobj_32b(9)
• struct panthor_syncobj_64b(9)
• enum panthor_group_state(9)
• struct panthor_group(9)
• group_queue_work(9)
• sched_queue_work(9)
• sched_queue_delayed_work(9)
• struct panthor_group_pool(9)
• struct panthor_job(9)
• group_bind_locked(9)
• group_unbind_locked(9)
• cs_slot_prog_locked(9)
• cs_slot_reset_locked(9)
• csg_slot_sync_priority_locked(9)
• cs_slot_sync_queue_state_locked(9)
• sched_process_global_irq_locked(9)
• panthor_sched_report_fw_events(9)
• panthor_sched_report_mmu_fault(9)
• panthor_fdinfo_gather_group_mem_info(9)

---

Okay that’s the whole struct panthor_queue(9) page, bestie. Source/version: ./drivers/gpu/drm/panthor · date: October 2026 — mwah, slay, and close the tab gently 💋🎀✨