drm 驱动系列 - 第三章 gem 内存管理

已于 2024-01-27 15:08:21 修改
阅读量2.3k 收藏 45
点赞数 29
分类专栏： linux drm 显示驱动 文章标签： linux 运维 服务器 驱动开发 嵌入式硬件 c语言
于 2023-11-29 17:13:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sty01z/article/details/134694799
版权

文章目录


作者: baron

drm 子系统使用 GEM (Graphic Execution Manager) 负责显示显存的分配和释放，他的整体框架如下图所示(图片是高清的, 如果看不清可以下载下来放大). drm 的内存管理分为几个部分组成.

  1. 显存的跟踪和管理这一块由 drm_vma_offset_manager 中 的 drm_mm 完成, 也就是图中的绿色部分
  2. 显存的分配和创建, 也就是图中的蓝色部分
  3. 显存的使用, 显存的使用分为两个部分, 一个是用户空间读写显存也就是红色部分, 另一个则是紫色部分

1、 drm_mm

drm 使用 drm_mm 来管理内存, 它使用 drm_mm_node 来对内存进行分区. 每一个 drm_mm_node 代表一块连续的内存区域. 这块内存可以被认为是被 “分配”或“占用”的，也可以是空闲的。

struct drm_mm {
 
    struct list_head hole_stack;
    struct drm_mm_node head_node; // 内存的分区
    ......
};

显卡驱动如果需要使用到 drm_mm 来管理内存则需要在一开始就调用 void drm_mm_init(struct drm_mm *mm, u64 start, u64 size);分配好需要管理的内存空间大小, 需要注意的是这里并不会实际分配真正的内存. 只是设置一个内存区域. 这个内存区域就我们要用到的总的显存大小, 如果你需要使用双 buffer , 则 size = buffer_size x 2 . 我们调用 drm_mm_init 初始化之后, 就会为我们创建一个 drm_mm 用来管理显存. 并且初始化一个默认的 drm_mm_node 用来表示整个空间的大小.

struct drm_mm_node {
    struct list_head node_list;
    struct list_head hole_stack;
    struct rb_node rb;
    ......
    u64 start;  // 保存地址的偏移量, 也就是我们申请的内存的 offset ==> drm_mode_map_dumb->offset
    u64 size;   // 这块内存的大小
    ......
    struct drm_mm *mm;
};

其中 start 成员变量表示 drm_mm_node 表示的显存的起始偏移地址.也就是我们调用 drmIoctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &map_req);时返回的 map_req->offset. 它表示的是内存的相对偏移, 这个 node 对应 drm_mm 中的内存偏移. 他的作用就是索引该 node.

1) 给驱动设置内存

#include <linux/module.h>
#include <drm/drm_crtc_helper.h>
#include <drm/drm_plane_helper.h>
#include <drm/drm_fb_cma_helper.h>
#include <drm/drm_gem_cma_helper.h>
#include <drm/drmP.h>
#include <drm/drm_mm.h>
#include <drm/drm_vma_manager.h>

#define WIDTH  1920
#define HEIGHT 1080

static struct drm_device *drm;

static const struct file_operations vkms_fops = {
    .owner = THIS_MODULE,
    .open = drm_open,
    .release = drm_release,
    .unlocked_ioctl = drm_ioctl,
    .poll = drm_poll,
    .read = drm_read,
};

static struct drm_driver vkms_driver = {
    .fops           = &vkms_fops,
    .name           = "vkms",
    .desc           = "Virtual Kernel Mode Setting",
    .date           = "20180514",
    .major          = 1,
    .minor          = 0,
};

static int vkms_drm_mm_init(struct drm_device *dev)
{
    struct drm_vma_offset_manager *mgr;

    mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);

    drm->vma_offset_manager = mgr;
    drm_mm_init(&mgr->vm_addr_space_mm, 0, WIDTH * HEIGHT * 2);

    return 0;
}

static void vkms_drm_mm_cleanup(struct drm_device *dev)
{
    kfree(dev->vma_offset_manager);
}

static int __init vkms_init(void)
{

    drm = drm_dev_alloc(&vkms_driver, NULL);
    vkms_drm_mm_init(drm); // 初始化 drm_mm
    drm_dev_register(drm, 0);

    return 0;
}

static void __exit vkms_exit(void)
{
    drm_dev_unregister(drm);
    vkms_drm_mm_cleanup(drm);
    drm_dev_unref(drm);
}

module_init(vkms_init);
module_exit(vkms_exit);

MODULE_AUTHOR("baron");
MODULE_DESCRIPTION("drm mm test drv");
MODULE_LICENSE("GPL");

在这段代码中我们初始化了 drm_mm 并设置了我们要管理的显存大小 1920 x 1080 x 2. 这里只是初始化, 因此我们还不能做什么. 但好歹我们有了一块可以分配的显存区域.为我们后续实验做准备.

2、 显存的分配和创建

drm 子系统已经为我们提供了一个默认的函数 drm_gem_cma_dumb_create用来分配和创建显存, 从名字就可以知道他包含三个部分 drm_gem_object、drm_gem_cma_object、dumb buffer(物理显存), 这个函数遵循先分配在创建的规则. 申请和创建的显存由 drm_gem_object 进行统一管理.


struct drm_gem_cma_object {
    struct drm_gem_object base; // 显存管理接口
    dma_addr_t paddr;           // 显存的物理地址
    struct sg_table *sgt;       // sg_table 本质上是由一块块单个物理连续的 buffer 所组成的链表，可以描述高端内存上分配出的离散 buffer. 也可以用来描述从低端内存上分配出的物理连续 buffe
    void *vaddr;                // 显存的虚拟地址
};

struct drm_gem_object {
    ......
    struct drm_device *dev;
    struct file *filp; // 该 gem 
    struct drm_vma_offset_node vma_node; // 管理分配显存描述符
    ......
    struct dma_buf *dma_buf;             // dma_buf 用于直接将这块显存进行共享
    struct dma_buf_attachment *import_attach;
}

这两个结构体是一体的, 在创建的时候我们创建 drm_gem_cma_object 结构时就会包含 drm_gem_object 接口. 这个技巧可以节省一点内存.其中 drm_gem_cma_object 还包含了我们申请的显存的地址信息. 因此 drm_gem_object 对内存的管理可以分为三个部分:

  1. 分配显存时的显存描述符 drm_vma_offset_node
  2. 分配到的物理内存的地址信息
  3. 提供 dma_buf 接口让显存实现共享.

drm_gem_cma_dumb_create 首先在 drm_mm 中申请一片需要的空间描述符, 然后再创建实际的物理内存. 上图中的蓝色的 drm_mm_node 就是 user 使用 libdrm 分配显存时申请到的内存空间描述符.之后再调用 dma_alloc_wc 分配实际的物理内存到drm_gem_object->drm_gem_cma_object. 具体流程如下所示.

drmIoctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &create); --> // 开放给上层的 libdrm 接口
    drm_gem_cma_dumb_create() -->
        drm_gem_cma_create_with_handle() -->
            drm_gem_cma_create() -->
                __drm_gem_cma_create() -->
                    if (drm->driver->gem_create_object) // 回调 gem_create_object 接口创建 gem_obj 
                        gem_obj = drm->driver->gem_create_object(drm, size); 
                    else
                        gem_obj = kzalloc(sizeof(*cma_obj), GFP_KERNEL); // 创建一个 gem obj
                    drm_gem_create_mmap_offset() -->    
                        drm_gem_create_mmap_offset_size() -->
                            drm_vma_offset_add() -->
                                drm_mm_insert_node() --> // 在 drm_mm 中查找到空闲可用的空间, 然后插入一个 drm_vma_offset_node 表示这个可用的空间.
                dma_alloc_wc() // 申请物理内存, 并将内存地址保存到 cma_obj

drm_gem_cma_dumb_create 主要实现了下面功能.

  1. 创建一个 cma_obj , 并且 gem_obj 是其成员变量. 初始化 gem_obj. 支持用户客制化, 用户需要自己实现这个接口 drm->driver->gem_create_object(drm, size);
  2. 在 dr_mm 中查找一段符合长度的内存空间, 并将 gem_obj->vma_node 插入到 drm_mm 并且占有这块空间. 即分配过程.
  3. 拿到这一段空间之后调用 dma_alloc_wc 申请实际的物理空间并将地址信息保存到 cma_obj.
  4. 在 drm_file->object_idr 中申请一个 handle, 用来关联 gem obj. 并返回给用户空间, 用户通过这个 handle 即可找到这个 gem.

1) 给驱动增加分配显存接口

给我们的驱动加上创建和分配的功能即 drm_gem_cma_dumb_create, 为了能找到对应的 node 因此提供 drm_gem_dumb_map_offset , 改接口用于返回 node 对应的 start 偏移.

#include <linux/module.h>
#include <drm/drm_crtc_helper.h>
#include <drm/drm_plane_helper.h>
#include <drm/drm_fb_cma_helper.h>
#include <drm/drm_gem_cma_helper.h>
#include <drm/drmP.h>
#include <drm/drm_mm.h>
#include <drm/drm_vma_manager.h>

#define WIDTH  1920
#define HEIGHT 1080

static struct drm_device *drm;

static const struct file_operations vkms_fops = {
    .owner = THIS_MODULE,
    .open = drm_open,
    .release = drm_release,
    .unlocked_ioctl = drm_ioctl,
    .poll = drm_poll,
    .read = drm_read,
};

static struct drm_driver vkms_driver = {
    .fops           = &vkms_fops,
    .driver_features    =  DRIVER_GEM,
    .name           = "vkms",
    .desc           = "Virtual Kernel Mode Setting",
    .date           = "20180514",
    .major          = 1,
    .minor          = 0,
    .dumb_create    = drm_gem_cma_dumb_create, // 在 drm_mm 中申请一个 node , 并分配物理内存
    .dumb_map_offset = drm_gem_dumb_map_offset, // 返回 node 中的 start 内存偏移, 即该 node 的索引
};

static int vkms_drm_mm_init(struct drm_device *dev)
{
    struct drm_vma_offset_manager *mgr;

    mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);

    drm->vma_offset_manager = mgr;
    drm_mm_init(&mgr->vm_addr_space_mm, 0, WIDTH * HEIGHT * 2);

    return 0;
}

static void vkms_drm_mm_cleanup(struct drm_device *dev)
{
    kfree(dev->vma_offset_manager);
}

static int __init vkms_init(void)
{

    drm = drm_dev_alloc(&vkms_driver, NULL);

    vkms_drm_mm_init(drm); // 初始化 drm_mm

    drm_dev_register(drm, 0);

    return 0;
}

static void __exit vkms_exit(void)
{
    drm_dev_unregister(drm);
    vkms_drm_mm_cleanup(drm);
    drm_dev_unref(drm);
}

module_init(vkms_init);
module_exit(vkms_exit);

MODULE_AUTHOR("baron");
MODULE_DESCRIPTION("drm mm test drv");
MODULE_LICENSE("GPL");

3、用户空间读写显存

经过前面的操作, 我们已经能够分配并且创建显存了, 现在我们需要在用户空间读写显存, 因此需要将显存映射到用户空间, 映射的方式有很多种. drm 子系统默认提供了 drm_gem_cma_mmap 接口来进行映射.

drm_gem_cma_mmap() --> 
    drm_gem_mmap(filp, vma); --> //  从 vma_offset_manager 中查找  vm_pgoff 偏移对应的 node, 通过 node 返回对应的 drm_gem_object, 对 vma 进行一初始化
        vma->vm_ops = dev->driver->gem_vm_ops; // drm_gem_mmap 中设置了 vm_ops 的回调, 在我们驱动中也要实现, 不然会 mmap 失败. 博主也不知道为啥, 有知道的同学可以告知一下.
    drm_gem_cma_mmap_obj(cma_obj, vma); --> 
        dma_mmap_wc(cma_obj->base.dev->dev, vma, cma_obj->vaddr, cma_obj->paddr, vma->vm_end - vma->vm_start); // 把 cma_obj 中描述的物理内存返映射到用户空间

1) 编程实验

一共增加了两个个接口 drm_gem_cma_mmap、drm_gem_cma_vm_ops

#include <linux/module.h>
#include <drm/drm_crtc_helper.h>
#include <drm/drm_plane_helper.h>
#include <drm/drm_fb_cma_helper.h>
#include <drm/drm_gem_cma_helper.h>
#include <drm/drmP.h>
#include <drm/drm_mm.h>
#include <drm/drm_vma_manager.h>

#define WIDTH  1920
#define HEIGHT 1080

static struct drm_device *drm;

static const struct file_operations vkms_fops = {
    .owner = THIS_MODULE,
    .open = drm_open,
    .release = drm_release,
    .unlocked_ioctl = drm_ioctl,
    .poll = drm_poll,
    .read = drm_read,
    .mmap = drm_gem_cma_mmap, // 实现 mmap 操作
};

static struct drm_driver vkms_driver = {
    .fops           = &vkms_fops,
    .driver_features    =  DRIVER_GEM,
    .name           = "vkms",
    .desc           = "Virtual Kernel Mode Setting",
    .date           = "20180514",
    .major          = 1,
    .minor          = 0,
    // 在 drm_gem_cma_mmap 中会设置这个回调函数. 在我们驱动中也要实现, 
    // 不然会 mmap 失败. 博主也不知道为啥, 有知道的同学可以告知一下.
    .gem_vm_ops     = &drm_gem_cma_vm_ops,     
    .dumb_create    = drm_gem_cma_dumb_create, // 在 drm_mm 中申请一个 node , 并分配物理内存
    .dumb_map_offset = drm_gem_dumb_map_offset, // 返回 node 中的 start 内存偏移, 即该 node 的索引
};

static int vkms_drm_mm_init(struct drm_device *dev)
{
    struct drm_vma_offset_manager *mgr;

    mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);

    drm->vma_offset_manager = mgr;
    drm_mm_init(&mgr->vm_addr_space_mm, 0, WIDTH * HEIGHT * 2);

    return 0;
}

static void vkms_drm_mm_cleanup(struct drm_device *dev)
{
    kfree(dev->vma_offset_manager);
}

static int __init vkms_init(void)
{

    drm = drm_dev_alloc(&vkms_driver, NULL);

    vkms_drm_mm_init(drm); // 初始化 drm_mm

    drm_dev_register(drm, 0);

    return 0;
}

static void __exit vkms_exit(void)
{
    drm_dev_unregister(drm);
    vkms_drm_mm_cleanup(drm);
    drm_dev_unref(drm);
}

module_init(vkms_init);
module_exit(vkms_exit);

MODULE_AUTHOR("baron");
MODULE_DESCRIPTION("drm mm test drv");
MODULE_LICENSE("GPL");

用户空间对显存进行读写. 这个程序就是照抄的龙哥的程序 https://blog.csdn.net/hexiaolong2009/article/details/106532966

#include <errno.h>
#include <fcntl.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>
#include <xf86drm.h>
#include <xf86drmMode.h>

int main(int argc, char **argv)
{
        int fd;
        char *vaddr;
        struct drm_mode_create_dumb create_req = {};
        struct drm_mode_destroy_dumb destroy_req = {};
        struct drm_mode_map_dumb map_req = {};

        fd = open("/dev/dri/card0", O_RDWR);

        create_req.bpp = 32;
        create_req.width = 240;
        create_req.height = 320;


        //  在 drm_vma_offset_manager 中分配一个 240 x 320 的显存, 并返回对应 gem obj 的 handle.
        drmIoctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_req);
        printf("create dumb: handle = %u, pitch = %u, size = %llu\n",
                create_req.handle, create_req.pitch, create_req.size);

        // 通过 handle 找到 gem, 返回对应 node 的 start 偏移 == map_req.offset
        map_req.handle = create_req.handle;
        drmIoctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &map_req);
        printf("get mmap offset 0x%llx\n", map_req.offset);

        // 使用这个 offeet 找到对应 node 并映射其描述的内存
        vaddr = mmap(0, create_req.size, PROT_WRITE, MAP_SHARED, fd, map_req.offset);
        strcpy(vaddr, "This is a dumb buffer!");
        munmap(vaddr, create_req.size);

        // 使用这个 offeet 找到对应 node 并映射其描述的内存
        vaddr = mmap(0, create_req.size, PROT_READ, MAP_SHARED, fd, map_req.offset);
        printf("read from mmap: %s\n", vaddr);
        munmap(vaddr, create_req.size);

        getchar();

        destroy_req.handle = create_req.handle;
        drmIoctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_req);
        close(fd);

        return 0;
}

运行结果:

[root@100ask:/dmabuf/2]# insmod drm_read_gpu.ko // 加载模块 ===> 不要纠结名字, 随便起的
[root@100ask:/dmabuf/2]#
[root@100ask:/dmabuf/2]#
[root@100ask:/dmabuf/2]# ./a.out
create dumb: handle = 1, pitch = 960, size = 307200
get mmap offset 0x0
read from mmap: This is a dumb buffer!
sty01z
关注
专栏目录
图显系统DRM GEM完全解析
多年芯片设计领域从业经验，负责芯片bringup以及kernel驱动开发。
09-12 3248
0. 引言 GEM 是Graphics execution management的缩写。沿袭了 TTM 的一些设计思想，提供一套显存管理的机制。 包括： 显存管理 控制对图形设备执行上下文的访问 处理现代图形硬件特有的 NUMA 需求 GEM 允许多个应用程序在不重新加载整个显卡的情况下，就可以访问到图形设备的资源。基于共享内存的思想保证了数据的同步性。显卡的上下文状态由 kernel 空间代码管理，这样就可以减少应用层对显卡状态管理的代码，使其将更多的精力放在图像算法上。 用户空间通过 ioctl 来
AMD GPU内存管理(2)：GEM/TTM
zhang_shuaifeng的博客
01-11 1906
DRM内存管理drm_mm、GEM/TTM内存管理
DRM内部结构之内存管理（二）
bai915290475的博客
04-06 801
在Linux DRM中，内存管理是一个关键组成部分，它负责处理图形硬件的内存分配、映射和同步。DRM提供了两种内存管理器：Translation Table Manager (TTM) 和 Graphics Execution Manager (GEM)。GEM是较新的内存管理器，它简化了内存管理并提供了更好的性能和灵活性。
Rockchip RK3399 - DRM驱动程序
Graceful_scenery的博客
09-08 788
如果我们需要编写一个DRM驱动，我们应该怎么做呢？具体流程如下： (1) 定义struct drm_driver，并初始化成员name、desc、data、major、minor、driver_features、fops、dumb_create等； (2)调用drm_dev_alloc函数分配并初始化一个struct drm_device； (3) 调用drm_mode_config_init初...
DRM Memory Management
08-09 632
一句话总结二者差异：TTM既支持集成显现，也支持独立显卡的显存管理；GEM只能支持集成显卡的显存管理。
DRM GEM 驱动程序开发（dumb）
热门推荐
hexiaolong2009的专栏
06-18 1万+
在上一篇《关于 DRM 中 DUMB 和 PRIME 名字的由来》 文章中，我们知道了 dumb buffer 名字的由来。本篇，我们将一起来写一个最简单的 GEM 驱动程序。
Linux图形子系统之GEM内存管理
fs3296的博客
03-29 4796
Linux图形子系统之GEM内存管理引言1 创建与映射1.1 创建GEM1.2 映射对象2 内存分配2.1 数据结构2.1.1 内存管理结构2.1.2 内存节点结构2.2 分配算法2.3 常见用法 引言 drm对内存使用抽象成GEM对象，用户空间通过句柄或文件映射的方式访问。 1 创建与映射 1.1 创建GEM drm_mode_create_dumb_ioctl是DRM_IOCTL_MODE_CREATE_DUMB的处理函数，它直接调用了drm_mode_create_dumb函数，该函数通过参数解析和检
linux drm 内存管理,linux DRM GEM 笔记
weixin_42131728的博客
05-09 971
在GPU上的各类操作中涉及到多种、多个buffer的使用。通常我们GPU是通过图像API来调用的，例如OPENGL、vulkan等，所以GPU上buffer的使用，实际上就是在这些图像API中被使用。例如在opengl es中，vertex/fragment shader、vertex index、vertex buffer object、uniform buffer object、texture...
驱动开发系列16 - Linux Graphics DRM和KMS内核模块介绍
最新发布
GPU全栈博主-程序哥
09-01 418
直接渲染管理器”（DRM）和“内核模式设置”（KMS）API 是 Linux 图形系统的重要组成部分。然而，关于它们具体是什么的文档非常难以找到——而谷歌搜索到的大部分内容都是完全过时的。看起来在这个领域工作的人们太忙了，无法进行文档编写。这篇文章提供了关于 DRM 内核模块内部实现细节的更详细信息。
RK1808 DRM 驱动流程分析
qq_40629752的博客
07-29 2020
rockchip drm驱动的启动流程图： 第一阶段： mipi_dsi_probe res = platform_get_resource(pdev, IORESOURCE_MEM, 0); //获取内存资源 dsi->irq = platform_get_irq(pdev, 0); //获取中断资源 dsi->pclk = devm_clk_get(dev, "pclk"); //获取pclk dsi->regmap = devm_regmap_init_mmio.
DRM详解，针对intel平台linux内核中的DRM的详解
08-14
这个文档是准对INTEL平台的linux内核中有关Display相关的文档。INTEL使用DRM的显卡驱动框架来管理视频输出。文档对DRM代码框架作出了详细解释。
常识 | drm kms 详解
qq_42278275的博客
10-26 2964
可以使用pci_map_rom()调用来映射BIOS，这是一个方便的函数，它负责映射实际的ROM，不管它是否已经被隐藏到内存中(通常在地址0xc0000)，还是存在于ROM BAR中的PCI设备上。相反，它遵循Unix“一切都是文件”的原则，通过文件系统名称空间公开gpu，使用/dev层次结构下的设备文件。通过使用辅助函数drm_gem_prime_export和drm_gem_prime_import，驱动程序可以在更简单的api中实现gem_prime_export和gem_prime_import。
[RK-Linux] RK3399 DRM驱动程序框架详解
Systemcall名屋
04-14 424
[RK-Linux] DRM驱动程序框架详解
Linux drm内存管理(二) TTM内存管理基础概念
负电离子的博客
02-28 2585
通过之前的文章我们知道了TTM是在GEM的基础上实现的一套GPU内存管理框架，
DRM驱动
ask_true的博客
04-20 1412
DRM驱动
DRM的GEM
ytfy339784578的专栏
02-28 5925
GEM(Graphics Execution Manager)主要完成：内存申请释放、指令执行、执行命令时的光圈管理(what?!)。缓存对象的申请主要与linux提供的shmem层相关。设备相关操作如指令执行、pinning、buffer读写、映射、域所有权的转移等，还是归设备驱动的ioctl。 初始化 使用GEM的驱动必须在struct drm_driver->driver_feat...
DRM驱动（二）之DRM驱动模块简介
fengchaochao123的博客
04-04 8977
做过显示的都知道，目前大多数厂商已经抛弃fb框架，使用drm驱动来管理显示。其中的优点是芯片厂商不必重复造轮子，只需将自己显示处理器的配置流程实现为函数，由drm驱动调用即可。同时drm也为用户提供同一接口，方便使用。
linux drm驱动分析
09-17
Linux DRM（Direct Rendering Manager）驱动是Linux操作系统中用于显卡和显示设备管理的驱动程序。它提供了一套统一的接口，使得用户可以通过应用程序直接访问显卡硬件，实现图形渲染和硬件加速等功能。 Linux DRM驱动包括了核心驱动模块和设备驱动模块。核心驱动模块负责提供基本的显卡管理功能，如内存分配、模式设置和渲染命令队列等。设备驱动模块负责支持特定显卡和显示设备的硬件特性和功能。通过这种模块化的设计，Linux DRM驱动能够支持多种显卡和显示设备。 在分析Linux DRM驱动时，可以从以下几个方面入手： 1. 驱动架构：了解Linux DRM驱动的整体架构，包括核心驱动模块和设备驱动模块的功能和交互方式。 2. 设备支持：分析特定显卡和显示设备的驱动模块，了解其支持的硬件特性和功能。 3. 内存管理：了解Linux DRM驱动中的内存管理机制，包括内存分配、显存管理和页面交换等。 4. 渲染和硬件加速：分析Linux DRM驱动中的渲染命令队列和硬件加速功能的实现方式。 5. 显示管道：了解Linux DRM驱动中的显示管道管理机制，包括模式设置和输出控制等。 通过对Linux DRM驱动的分析，可以更深入地理解显卡和显示设备的工作原理，为开发应用程序和调优系统性能提供指导和参考。此外，还可以通过分析和改进Linux DRM驱动来实现新的显卡和显示设备的支持，提升系统的兼容性和性能。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值