// meson_gem.c:636
struct am_meson_gem_object *am_meson_gem_object_create(
    struct drm_device *dev,
    unsigned int flags,
    unsigned long size)
{
    // 1. 分配 am_meson_gem_object 结构体
    meson_gem_obj = kzalloc(sizeof(*meson_gem_obj), GFP_KERNEL);
    
    // 2. 初始化 DRM GEM 对象
    ret = drm_gem_object_init(dev, &meson_gem_obj->base, size);
    
    // 3. 根据 flags 分配内存缓冲区
    if ((flags & MESON_USE_VIDEO_PLANE) && (flags & MESON_USE_PROTECTED))
        ret = am_meson_gem_alloc_video_secure_buff(meson_gem_obj);  // 安全内存
    else
        ret = am_meson_gem_alloc_ion_buff(meson_gem_obj, flags);    // ION/DMA heap
    
    // 4. 如果是 UVM 缓冲区，初始化 uvm_buf_obj
    if (meson_gem_obj->is_uvm) {
        meson_gem_obj->ubo.arg = meson_gem_obj;
        meson_gem_obj->ubo.dev = dev->dev;
    }
    
    return meson_gem_obj;
}

// meson_gem.c:60 - 内存分配核心函数
static int am_meson_gem_alloc_ion_buff(struct am_meson_gem_object *meson_gem_obj, int flags)
{
    // 优先级：heap-fb -> heap-gfx -> heap-codecmm -> system
    char DMAHEAP[][20] = {"heap-fb", "heap-gfx", "heap-codecmm"};
    
    for (i = 0; i < 3; i++) {
        heap = dma_heap_find(DMAHEAP[i]);
        dmabuf = dma_heap_buffer_alloc(heap, size, O_RDWR, DMA_HEAP_VALID_HEAP_FLAGS);
        if (!IS_ERR_OR_NULL(dmabuf))
            break;
    }
    
    // 创建 DMA attachment 和 sg_table
    attachment = dma_buf_attach(dmabuf, dev->dev);
    sg_table = dma_buf_map_attachment(attachment, DMA_BIDIRECTIONAL);
    
    // 同步 cache
    dma_sync_sg_for_device(dev->dev, sg_table->sgl, sg_table->nents, DMA_TO_DEVICE);
    
    // 获取物理地址
    meson_gem_obj->addr = PFN_PHYS(page_to_pfn(page));
}

// meson_gem.c:306 - GEM 对象释放
void meson_gem_object_free(struct drm_gem_object *obj)
{
    struct am_meson_gem_object *meson_gem_obj = to_am_meson_gem_obj(obj);
    
    // 1. 安全内存释放
    if ((flags & MESON_USE_VIDEO_PLANE) && (flags & MESON_USE_PROTECTED))
        am_meson_gem_free_video_secure_buf(meson_gem_obj);
    // 2. ION/DMA heap 释放
    else if (!obj->import_attach)
        am_meson_gem_free_ion_buf(obj->dev, meson_gem_obj);
    // 3. Prime 导入的缓冲区释放
    else
        drm_prime_gem_destroy(obj, meson_gem_obj->sg);
    
    // 4. 释放 mmap offset
    drm_gem_free_mmap_offset(obj);
    
    // 5. 释放 GEM 对象引用
    drm_gem_object_release(obj);
    
    kfree(meson_gem_obj);
}

// meson_crtc.c:236 - Fence ops 定义
static const char *meson_crtc_fence_get_driver_name(struct dma_fence *fence)
{
    return "meson";
}

static const char *meson_crtc_fence_get_timeline_name(struct dma_fence *fence)
{
    return "present_fence";  // Timeline 名称
}

static const struct dma_fence_ops meson_crtc_fence_ops = {
    .get_driver_name = meson_crtc_fence_get_driver_name,
    .get_timeline_name = meson_crtc_fence_get_timeline_name,
};

// 创建 fence
struct dma_fence *meson_crtc_create_fence(spinlock_t *lock)
{
    fence = kzalloc(sizeof(*fence), GFP_KERNEL);
    dma_fence_init(fence, &meson_crtc_fence_ops, lock, 0, 0);
    return fence;
}

// meson_crtc.c:265 - IOCTL 实现
int meson_crtc_creat_present_fence_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
{
    struct drm_meson_present_fence *arg = data;
    struct am_meson_crtc *amcrtc = ...;
    
    // 创建 fence
    fence = meson_crtc_create_fence(&pre_fence->lock);
    
    // 导出为 sync_file fd
    sync_file = sync_file_create(fence);
    fd = get_unused_fd_flags(O_CLOEXEC);
    fd_install(fd, sync_file->file);
    
    arg->fd = fd;
    pre_fence->fence = fence;
    pre_fence->sync_file = sync_file;
}

// meson_plane.c:859 - Video fence 创建
static struct dma_fence *am_meson_video_create_fence(spinlock_t *lock)
{
    fence = kzalloc(sizeof(*fence), GFP_KERNEL);
    dma_fence_init(fence, &am_meson_video_plane_fence_ops, lock, 0, 0);
    return fence;
}

// Fence 与 vframe 绑定
static void bind_video_fence_vframe(struct meson_vpu_video *video, 
    struct dma_fence *fence, u32 index, struct vframe_s *vf)
{
    info->fence = fence;
    info->vf = vf;
}

// Fence 信号 - 当视频帧显示完成时调用
static void video_fence_signal(struct meson_vpu_video *video, struct vframe_s *vf)
{
    list_for_each_safe(...) {
        if (info_cur->vf == vf) {
            dma_fence_signal(info_cur->fence);  // 信号 fence
            dma_fence_put(info_cur->fence);
            info_cur->fence = NULL;
        }
    }
}

// meson_atomic.c:185 - Commit tail 阶段
static void meson_commit_tail(struct drm_atomic_state *old_state)
{
    // 1. 等待所有 plane 的 fence
    drm_atomic_helper_wait_for_fences(dev, old_state, false);
    
    // 2. 等待之前的 commit 完成
    meson_drm_atomic_helper_wait_for_dependencies(old_state);
    
    // 3. 执行硬件配置
    if (funcs->atomic_commit_tail)
        funcs->atomic_commit_tail(old_state);
    
    // 4. 标记完成
    drm_atomic_helper_commit_cleanup_done(old_state);
}

// meson_async_atomic.c:86 - 读取 in_fence_fd
} else if (property == config->prop_in_fence_fd) {
    if (state->fence)
        return -EINVAL;
    
    state->fence = sync_file_get_fence(val);  // 获取用户空间的 fence
    if (!state->fence)
        return -EINVAL;
}

// meson_crtc.c:141 - CRTC state 复制
static struct drm_crtc_state *meson_crtc_duplicate_state(struct drm_crtc *crtc)
{
    new_state = kzalloc(sizeof(*new_state), GFP_KERNEL);
    
    // 复制基础 state
    __drm_atomic_helper_crtc_duplicate_state(crtc, &new_state->base);
    
    // 复制私有 state
    new_state->crtc_hdr_process_policy = cur_state->crtc_hdr_process_policy;
    new_state->crtc_dv_enable = cur_state->crtc_dv_enable;
    new_state->vmode = cur_state->vmode;
    new_state->seamless = cur_state->seamless;
    // ...
    
    return &new_state->base;
}

// meson_atomic.c:652 - Commit tail RPM
void meson_atomic_helper_commit_tail_rpm(struct drm_atomic_state *old_state)
{
    // 1. 禁用不再使用的资源
    drm_atomic_helper_commit_modeset_disables(dev, old_state);
    
    // 2. 使能需要使用的资源（模式设置）
    drm_atomic_helper_commit_modeset_enables(dev, old_state);
    
    // 3. 配置 plane（帧缓冲、位置、缩放）
    drm_atomic_helper_commit_planes(dev, old_state, DRM_PLANE_COMMIT_ACTIVE_ONLY);
    
    // 4. 伪造 vblank
    drm_atomic_helper_fake_vblank(old_state);
    
    // 5. 标记硬件完成
    drm_atomic_helper_commit_hw_done(old_state);
    
    // 6. 等待 vblank
    meson_drm_atomic_helper_wait_for_vblanks(dev, old_state);
    
    // 7. 清理 plane 资源
    drm_atomic_helper_cleanup_planes(dev, old_state);
}

// meson_crtc.c:655 - CRTC enable
static void am_meson_crtc_atomic_enable(struct drm_crtc *crtc, 
    struct drm_atomic_state *state)
{
    // 验证并设置显示模式
    vout_func_validate_vmode(state->mode.name);
    vout_func_set_state(state->mode.name);
    
    // 更新 VIU 配置
    vout_func_update_viu();
    
    // 开启 vblank 中断
    drm_crtc_vblank_on(crtc);
}

// meson_atomic.c:120 - 等待 commit 完成
static int meson_drm_crtc_commit_wait(struct drm_crtc_commit *commit)
{
    // 1. 等待硬件编程完成 (100ms 超时)
    ret = wait_for_completion_timeout(&commit->hw_done, HZ / 10);
    if (!ret)
        return -ETIMEDOUT;
    
    // 2. 等待 flip 完成
    ret = wait_for_completion_timeout(&commit->flip_done, HZ / 10);
    if (!ret)
        return -ETIMEDOUT;
    
    return 0;
}

// drm_crtc_commit 结构
struct drm_crtc_commit {
    struct completion flip_done;     // 用户空间 flip 完成
    struct completion hw_done;      // 硬件编程完成
    struct completion cleanup_done; // 清理完成
    struct drm_crtc *crtc;
    struct drm_pending_vblank_event *event;
};

// DRM framework - drm_atomic_state
struct drm_atomic_state {
    struct drm_device *dev;
    struct drm_modeset_acquire_ctx *acquire_ctx;
    
    // 状态数组指针
    struct drm_crtc_state **crtc_states;
    struct drm_plane_state **plane_states;
    struct drm_connector_state **connector_states;
    
    // Commit 跟踪
    struct drm_crtc_commit **crtcs;
    struct work_struct commit_work;  // 异步 commit work
    
    bool allow_modeset:1;
    bool legacy_cursor_update:1;
    bool async_update:1;
};

// Meson 私有 CRTC state
struct am_meson_crtc_state {
    struct drm_crtc_state base;
    enum vmode_e vmode;              // 当前显示模式
    enum vmode_e preset_vmode;       // 预设模式
    bool seamless;                   // 无缝切换
    bool crtc_dv_enable;            // Dolby Vision
    bool crtc_hdr_enable;           // HDR
    u8 crtc_hdr_process_policy;     // HDR 处理策略
};

// meson_crtc.c:841 - CRTC atomic check
static int meson_crtc_atomic_check(struct drm_crtc *crtc, 
    struct drm_atomic_state *state)
{
    struct am_meson_crtc_state *new_state = to_am_meson_crtc_state(state);
    
    // 检查 HDR/DV 参数变化
    if (new_state->crtc_hdr_process_policy != cur_state->crtc_hdr_process_policy ||
        new_state->crtc_dv_enable != cur_state->crtc_dv_enable) {
        new_state->base.mode_changed = true;
    }
    
    // VPU pipeline 检查
    return vpu_pipeline_check(priv->pipeline, crtc, state);
}

// drm_atomic_helper_swap_state - 交换新旧 state
int drm_atomic_helper_swap_state(struct drm_atomic_state *state, bool commit)
{
    // 遍历所有 CRTC
    for_each_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
        // 1. 保存当前硬件状态到 old_crtc_state
        crtc->funcs->atomic_flush(crtc, old_crtc_state);
        
        // 2. 用 new_crtc_state 替换 crtc->state
        crtc->state = new_crtc_state;
        new_crtc_state->state = state;
    }
    
    // 同样的逻辑应用于 plane 和 connector
}

// drm_atomic_helper_swap_state - 交换新旧 state
int drm_atomic_helper_swap_state(struct drm_atomic_state *state, bool commit)
{
    // 遍历所有 CRTC
    for_each_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
        // 1. 保存当前硬件状态到 old_crtc_state
        crtc->funcs->atomic_flush(crtc, old_crtc_state);
        
        // 2. 用 new_crtc_state 替换 crtc->state
        crtc->state = new_crtc_state;
        new_crtc_state->state = state;
    }
    
    // 同样的逻辑应用于 plane 和 connector
}

// meson_async_atomic.c - 锁初始化
struct drm_modeset_acquire_ctx ctx;
drm_modeset_acquire_init(&ctx, 0);
state->acquire_ctx = &ctx;

// 死锁处理
if (ret == -EDEADLK) {
    drm_atomic_state_clear(state);
    drm_modeset_backoff(&ctx);  // 随机化锁获取顺序
    goto retry;
}

// meson_async_atomic.c
state->allow_modeset = false;  // Async atomic 禁用 modeset

// meson_crtc.c - 强制 mode changed
if (atomic_state->allow_modeset) {
    if (cur_state->crtc_dv_enable != new_state->crtc_dv_enable)
        crtc_state->mode_changed = true;
}

// meson_crtc.c - 复制 state
static struct drm_crtc_state *meson_crtc_duplicate_state(struct drm_crtc *crtc)
{
    struct am_meson_crtc_state *new_state, *cur_state;
    cur_state = to_am_meson_crtc_state(crtc->state);
    
    new_state = kzalloc(sizeof(*new_state), GFP_KERNEL);
    __drm_atomic_helper_crtc_duplicate_state(crtc, &new_state->base);
    
    // 复制 Meson 特定状态
    new_state->crtc_hdr_process_policy = cur_state->crtc_hdr_process_policy;
    new_state->crtc_dv_enable = cur_state->crtc_dv_enable;
    new_state->vmode = cur_state->vmode;
    new_state->seamless = false;  // 新状态默认非 seamless
    
    return &new_state->base;
}

// 失败时的恢复机制
void drm_atomic_state_clear(struct drm_atomic_state *state)
{
    int i;
    
    // 清理 connector states
    for (i = 0; i < state->num_connector; i++) {
        if (state->connectors[i].state) {
            drm_connector_state_put(state->connectors[i].state);
            state->connectors[i].state = NULL;
        }
    }
    // 同样的逻辑用于 CRTC 和 Plane
}

// Meson 驱动错误处理
err:
    drm_atomic_helper_cleanup_planes(dev, state);
    return ret;

// meson_atomic.c
if (state->legacy_cursor_update) {
    ret = drm_atomic_helper_setup_commit(state, nonblock);
    state->legacy_cursor_update = false;
}

// meson_crtc.c - Pipeline 级别状态
static void meson_crtc_atomic_print_state(...)
{
    struct meson_vpu_pipeline_state *mvps;
    struct drm_private_state *obj_state;
    
    obj_state = priv->pipeline->obj.state;
    mvps = container_of(obj_state, struct meson_vpu_pipeline_state, obj);
}

// meson_drv.c:283 - DRM bind
static int am_meson_drm_bind(struct device *dev)
{
    // 1. 初始化 DRM 设备
    drm = drm_dev_alloc(&meson_driver, dev);
    
    // 2. 初始化 mode config
    drm_mode_config_init(drm);
    
    // 3. 初始化 VPU topology
    vpu_topology_init(pdev, priv);
    
    // 4. 绑定所有子组件驱动 (HDMI, LCD, CVBS)
    ret = component_bind_all(dev, &priv->bound_data);
    
    // 5. 初始化 per-CRTC commit 线程
    ret = meson_worker_thread_init(priv, drm->mode_config.num_crtc);
    
    // 6. 注册 DRM 设备
    drm_dev_register(drm, 0);
}

// meson_of_parser.c - 设备树解析
struct meson_of_conf {
    u32 crtc_masks[ENCODER_MAX];  // 每个 encoder 可用的 CRTC
    u32 crtcmask_osd;             // OSD 层 CRTC 映射
    u32 crtcmask_video;           // Video 层 CRTC 映射
};

// 默认配置
for (i = 0; i < ENCODER_MAX; i++)
    conf->crtc_masks[i] = 1;  // 默认使用 CRTC0

// 设备树覆盖示例:
// crtc_masks = <0x1>, <0x2>, <0x4>  // HDMI->CRTC0, LCD->CRTC1, CVBS->CRTC2

// meson_atomic.c:470 - commit 入口
int meson_atomic_commit(struct drm_device *dev, 
    struct drm_atomic_state *state, bool nonblock)
{
    // 设置 commit 跟踪结构
    ret = meson_drm_atomic_helper_setup_commit(state, nonblock);
    
    // 准备 plane 资源
    ret = drm_atomic_helper_prepare_planes(dev, state);
    
    // 交换 state
    ret = drm_atomic_helper_swap_state(state, true);
    
    if (nonblock) {
        // 创建 kthread work
        work_item->crtc_id = crtc_index;
        kthread_init_work(&work_item->kthread_work, meson_commit_work);
        
        // 队列到 per-CRTC worker
        worker = &priv->commit_thread[crtc_index].worker;
        kthread_queue_work(worker, &work_item->kthread_work);
        
        return 0;  // 立即返回
    } else {
        // 同步等待完成
        meson_commit_tail(state);
    }
}

// meson_atomic.c:491 - async update 路径
if (state->async_update) {
    // 准备 plane
    ret = drm_atomic_helper_prepare_planes(dev, state);
    
    // 交换 state
    ret = drm_atomic_helper_swap_state(state, true);
    
    // 直接执行 plane update，不走完整 commit
    meson_atomic_helper_async_commit(dev, state);
    
    // 清理
    drm_atomic_helper_cleanup_planes(dev, state);
    
    return 0;
}

// hdmitx21/hdmi_tx_video.c - 视频参数配置
struct hdmi_video_format {
    u32 hsync_width;    // 水平同步宽度
    u32 hback_porch;   // 后沿
    u32 hactive;       // 有效像素
    u32 hfront_porch;  // 前沿
    
    u32 vsync_width;   // 垂直同步
    u32 vback_porch;
    u32 vactive;
    u32 vfront_porch;
    
    u32 pixel_repeat;  // 像素重复
    u32 color_depth;   // 色深 (8/10/12-bit)
};

// meson_writeback.h - Amlogic 扩展的 writeback 结构
struct am_drm_writeback {
    struct meson_connector base;                    // 基类
    struct drm_writeback_connector wb_connector;   // DRM writeback connector
    struct drm_device drm_dev;                    // DRM 设备
    struct work_struct writeback_work;             // 捕获工作队列
    struct workqueue_struct *writeback_wq;        // workqueue
    struct drm_framebuffer *fb;                   // 目标帧缓冲
    u32 capture_port;                             // 捕获端口
    struct drm_property *capture_port_prop;        // 捕获端口属性
};

// DRM framework - writeback connector
struct drm_writeback_connector {
    struct drm_connector base;
    struct drm_encoder encoder;
    // ...
};

// meson_writeback.c:396 - Writeback 初始化
int am_meson_writeback_create(struct drm_device *drm)
{
    // 1. 分配 writeback 结构
    drm_writeback = kzalloc(sizeof(*drm_writeback), GFP_KERNEL);
    
    // 2. 设置 encoder 的 CRTC 掩码
    wb_connector->encoder.possible_crtcs = BIT(0);
    
    // 3. 获取支持的像素格式
    ret = meson_writeback_get_format(writeback_fmts);
    
    // 4. 注册 writeback connector
    ret = drm_writeback_connector_init(drm, wb_connector,
        &am_writeback_connector_funcs,
        &am_writeback_encoder_helper_funcs,
        writeback_fmts, ARRAY_SIZE(writeback_fmts));
    
    // 5. 创建 workqueue
    drm_writeback->writeback_wq = alloc_workqueue("writeback_capture",
        WQ_HIGHPRI | WQ_CPU_INTENSIVE, 0);
    
    // 6. 初始化 work
    INIT_WORK(&drm_writeback->writeback_work, meson_writeback_capture_work);
}

// meson_writeback.c:50 - Atomic check
static int meson_writeback_connector_atomic_check(struct drm_connector *conn,
    struct drm_atomic_state *state)
{
    conn_state = drm_atomic_get_new_connector_state(state, conn);
    
    // 检查是否有 writeback job
    if (!conn_state->writeback_job)
        return 0;
    
    crtc_state = drm_atomic_get_new_crtc_state(state, conn_state->crtc);
    fb = conn_state->writeback_job->fb;
    
    // 检查帧缓冲尺寸是否匹配
    if (fb->width != crtc_state->mode.hdisplay ||
        fb->height != crtc_state->mode.vdisplay) {
        DRM_ERROR("Invalid framebuffer size %ux%u\n", fb->width, fb->height);
        return -EINVAL;
    }
    
    // 检查像素格式是否支持
    for (i = 0; i < ARRAY_SIZE(writeback_fmts); i++) {
        if (fb->format->format == writeback_fmts[i])
            break;
    }
    
    return 0;
}

// meson_writeback.c:194 - Atomic commit
static void meson_writeback_connector_atomic_commit(struct drm_connector *conn,
    struct drm_atomic_state *old_atomic_state)
{
    conn_state = drm_atomic_get_old_connector_state(old_atomic_state, conn);
    drm_writeback = connector_to_am_writeback(conn);
    fb = conn_state->writeback_job->fb;
    drm_writeback->fb = fb;
    
    // 队列到 workqueue 执行捕获
    drm_writeback_queue_job(&drm_writeback->wb_connector, conn_state);
    queue_work(drm_writeback->writeback_wq, &drm_writeback->writeback_work);
}

// meson_writeback.c:182 - Work 处理
static void meson_writeback_capture_work(struct work_struct *work)
{
    drm_writeback = container_of(work, struct am_drm_writeback, writeback_work);
    
    // 执行实际捕获
    meson_writeback_capture_picture(drm_writeback->fb, drm_writeback->capture_port);
    
    // 通知完成
    drm_writeback_signal_completion(&drm_writeback->wb_connector, 0);
}

// meson_writeback.c:352 - 捕获端口枚举
static const struct drm_prop_enum_list writeback_capture_port_enum_list[] = {
    { TVIN_PORT_VIU1_WB0_VD1, "video" },      // 仅视频层
    { TVIN_PORT_VIU1_WB0_OSD1, "osd" },       // 仅 OSD 层
    { TVIN_PORT_VIU1_WB0_VPP, "video&osd" }, // 视频和 OSD 混合
};

// 用户空间使用示例
struct drm_mode_capture {
    u32 fb_id;          // 捕获目标帧缓冲
    u32 out_fence;       // 输出 fence
    u32 connector_id;    // writeback connector ID
    u32 flags;
};

// 1. 创建用于捕获的帧缓冲
drmModeFB2Create(dev, width, height, DRM_FORMAT_NV12, handles, pitches, offsets, &fb_id);

// 2. 提交 writeback job
drm_writeback_queue_job(connector, fb_id, &out_fence);

// 3. 等待捕获完成
sync_file_wait(out_fence, 1000);

// 4. 使用捕获的缓冲区
// ... 对捕获内容进行处理

// meson_atomic.c:573 - 同步 commit 路径
if (!nonblock) {
    meson_commit_reenter_inc(priv, crtc_index, BLOCK_MODE);
    meson_commit_tail(state);  // 同步等待完成
    meson_commit_reenter_dec(priv, crtc_index, BLOCK_MODE);
}

// meson_atomic.c:564 - 非阻塞 commit 入口
if (nonblock) {
    work_item = kzalloc(sizeof(*work_item), GFP_KERNEL);
    work_item->work = &state->commit_work;
    work_item->crtc_id = crtc_id;
    work_item->commit_flag = nonblock;
    
    // 初始化 kthread work
    kthread_init_work(&work_item->kthread_work, meson_commit_work);
    
    // 队列到 per-CRTC worker
    worker = &priv->commit_thread[crtc_index].worker;
    kthread_queue_work(worker, &work_item->kthread_work);
    
    return 0;  // 立即返回，不等待完成
}

// meson_atomic.c:238 - 异步执行
static void meson_commit_work(struct kthread_work *work)
{
    struct meson_commit_work_item *work_item = container_of(work,
        struct meson_commit_work_item, kthread_work);
    struct drm_atomic_state *state = container_of(work_item->work,
        struct drm_atomic_state, commit_work);
    
    meson_commit_reenter_inc(priv, work_item->crtc_id, NONBLOCK_MODE);
    meson_commit_tail(state);  // 在 kthread 中执行
    meson_commit_reenter_dec(priv, work_item->crtc_id, NONBLOCK_MODE);
    kfree(work_item);
}

// meson_drv.c:233 - 为每个 CRTC 创建独立线程
static int meson_worker_thread_init(struct meson_drm *priv, unsigned int num_crtcs)
{
    for (i = 0; i < num_crtcs; i++) {
        worker = &drm_thread->worker;
        kthread_init_worker(worker);
        
        // 创建高优先级线程 (SCHED_FIFO, priority=16)
        snprintf(thread_name, 16, "crtc%d_commit", i);
        drm_thread->thread = kthread_run(kthread_worker_fn, worker, thread_name);
        
        sched_setscheduler(drm_thread->thread, SCHED_FIFO, &param);
    }
}

// meson_atomic.c:491 - async update 路径
if (state->async_update) {
    priv->pan_async_commit_ran = true;
    
    // 准备 plane 资源
    ret = drm_atomic_helper_prepare_planes(dev, state);
    
    // 交换 state
    ret = drm_atomic_helper_swap_state(state, true);
    
    // 直接执行 plane 更新，跳过完整 commit
    meson_atomic_helper_async_commit(dev, state);
    
    // 清理
    drm_atomic_helper_cleanup_planes(dev, state);
    
    return 0;
}

// meson_plane.c:1740 - Video plane 异步更新
void meson_video_plane_async_update(struct drm_plane *plane, struct drm_atomic_state *state)
{
    new_state = drm_atomic_get_new_plane_state(state, plane);
    
    // 更新 plane 状态（原地修改）
    plane->state->fb = new_state->fb;
    plane->state->src_x = new_state->src_x;
    plane->state->crtc_x = new_state->crtc_x;
    
    // 准备 video fence（如果是新帧）
    if (!meson_video_plane_is_repeat_frame(plane, new_state))
        meson_video_prepare_fence(plane, new_state, mvv);
    
    // 更新硬件
    vpu_pipeline_video_update(sub_pipe, new_state->state);
}

// meson_async_atomic.c:375 - 设置 legacy 标志
state->legacy_cursor_update = true;
ret = drm_atomic_commit(state);

// meson_atomic.c:376 - legacy cursor 特殊处理
if (state->legacy_cursor_update) {
    ret = meson_drm_atomic_helper_setup_commit(state, nonblock);
    state->legacy_cursor_update = false;  // 强制清除
    DRM_DEBUG_ATOMIC("legacy_cursor_update force to false!\n");
}

// meson_atomic.c:470 - 入口判断
int meson_atomic_commit(..., bool nonblock)
{
    // 1. 检查是否是 async_update
    if (state->async_update) {
        // 走 Async Update 快速路径
        return handle_async_update(dev, state);
    }
    
    // 2. 检查是否是 legacy_cursor_update
    if (state->legacy_cursor_update) {
        // 走 Legacy Cursor 路径
        return handle_legacy_cursor(dev, state);
    }
    
    // 3. 根据 nonblock 标志选择
    if (nonblock) {
        // 队列到 kthread，异步执行
        kthread_queue_work(...);
        return 0;
    } else {
        // 同步执行
        meson_commit_tail(state);
        return 0;
    }
}