注：文章都是通过阅读各位前辈总结的资料 Android 11.0 && Linux（Kernel 4.19）Rockchip平台源码、加上自己的思考分析总结出来的，其中难免有理解不对的地方，欢迎大家批评指正。文章为个人学习、研究、欣赏之用，图文内容整理自互联网，如有侵权，请联系删除（◕‿◕），转载请注明出处（©Rockchip ©Android @Linux 版权所有），谢谢。

（==文章基于 Kernel-4.19==）&&（==文章基于 Android 11.0==）

【zhoujinjian.com博客原图链接】

【开发板 RockPi4bPlusV1.6】

【开发板 RockPi4bPlusV1.6 Android 11.0 && Linux（Kernel 4.19）源码链接】：（repo init -u https://github.com/radxa/manifests.git -b Android11_Radxa_rk11.1 -m rockchip-r-release.xml）

【开发板 RockPi4bPlusV1.6 Android 11.0 && Linux（Kernel 4.19）编译指南】

正是由于前人（各位大神）的分析和总结，帮助我节约了大量的时间和精力，特别感谢，由于不喜欢图片水印，去除了水印，敬请谅解！！！

本文转自Rockchip RK3399 - DRM驱动程序，如有侵权，请联系删除。

开发板 ：ROCK Pi 4B+开发板
eMMC ：32GB
LPDDR4 ：4GB
显示屏 ：7英寸HDMI接口显示屏
u-boot ：2017.09
linux ：4.19

如果我们需要编写一个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_device中mode_config结构体；

(4) 调用drm_xxx_init创建 framebuffer、plane、crtc、encoder、connector 这5个 drm_mode_object；

(5) 调用drm_dev_register注册drm_device；

一、显示子系统概述

显示子系统是Rockchip平台显示输出相关软硬件系统的统称，linux内核采用component框架来构建显示子系统，一个显示子系统由显示处理器（vop，video output processor）、接口控制器（mipi，lvds，hdmi、edp、dp、rgb、BT1120、BT656、I8080（MCU 显示接口）等)、液晶背光，电源等多个独立的功能模块构成。

那么问题来了，什么是显示处理器？

  • 将在内存中的图像数据，转化为电信号送到显示设备称为显示控制器，比如早期的LCDC；
  • 后面进行了拓展，可以处理一些简单的图像，比如缩放、旋转、合成等，如瑞芯的vop，高通的sde称为显示处理器；

显示处理器可以在没有CPU参与的情况下可以做一些简单的图像处理，比如：

  • 缩放，旋转等操作；
  • 支持多层，并可以进行合成，支持porter-duff；
  • 支持多种显存格式（ARGB888,RGB565, 包括GPU输出的tile格式以及fbdc压缩格式）等；
  • 支持生成时序信号如tcon，送给如mipi、lvds等接口；
  • 支持多种分辨率；

1.1 硬件框图

整个显示系统的硬件框架如下图所示：

VOP 1.0显示子系统架构

VOP 2.0显示子系统架构

从上面的框图可以看到，在整个显示通路的最后端，是由RGA，GPU、VPU组成的显示图形加速模块，他们是专门针对图像处理优化设计的硬件IP，能够高效的进行图像的⽣成和进一步处理（比如GPU通过opengl功能提供图像渲染功能，RGA可以对图像数据进行缩放，旋转，合成等2D处理，VPU可以高效的进行视频解码），从而减轻CPU负担。

经过这些图像加速模块处理后的数据会存放在DDR中，然后由VOP读取，根据应用需求进行Alpha叠加，颜色空间转换，gamma矫正，HDR转换 等处理后，再发送到对应的显示接口模块（HDMI、eDP/DP、DSI、RGB/BT1120/BT656、LVDS）, 这些接口模块会把接收到的数据转换成符合各⾃协议的数据流，发送到显示器或者屏幕上，呈现在最终用户眼前。

目前Rockchip平台上存在两种VOP架构：

  • VOP 1.0：VOP 1.0是用多VOP的方式来实现多屏幕显示，即正常情况下，一个VOP在同一时刻只能输出一路独立的显示时序，驱动一个屏幕显示独立的内容。如果需要实现双屏显示，则需要有两个VOP来实现，所以在RK3288，RK3399，PX30等⽀持双显的平台上，都有两个独立的VOP；
  • VOP 2.0：VOP 2.0采用了统一显示架构，即整个SoC上只存在一个VOP，但是在VOP的后端设计了多路独立的Video Port(简称 VP) 输出接口，这些 VP能够同时独立⼯作，并且输出相互独立的显示时序。比如在上面的VOP 2.0框图中，有三个VP，就能同时实现三屏异显；
1.1.1 RK3399

RK3399有2个VOP：

  • Video Output Processor(VOP_BIG)：supports 4096x2160 with AFBC;
  • Video Output Processor(VOP_LIT)：supports 2560x1600；

支持的显示接口：

  • 双通道MIPI DSI(4线/通道)显示接口；
  • 1个eDP显示接口；
  • 1个DP显示接口；
  • 1个HDMI显示接口；

RK3399支持的最大输出分辨率和协议标准如下：

显示接口 最大输出 协议标准
eDP VOP BIG: 3840x2160@60hz
VOP LITE: 2560x1600@60hz 支持 DP1.2a 和 eDP1.3 协议标准
MIPI 单通道：1920x1080@60hz
双通道：2560x1600@60hz 支持 DSI v1.1，DCS v1.1，DPHY v1.1 协议标准
HDMI VOP BIG:：4096X2160@60hz
VOP LITE: 2560x1600@60hz 支持 HDMI 1.4a 和 2.0a 协议标准
DP VOP BIG:：4096X2160@60hz
VOP LITE: 2560x1600@60hz 支持 DP 1.2 协议标准
1.1.2 ROCK Pi 4B+

我们所使用的的ROCK Pi 4B+开发板，视频输出支持：

  • LCD Interface: 一个eDP 1.3（4线，10.8Gbps）, 一个或2个4线MIPI DSI；
  • DP on Type-C: DisplayPort 1.2 Alt Mode on USB Type-C ;
  • HDMI: HDMI 2.0a, 支持4K@60Hz显示，支持HDCP 1.4/2.2;

1.2 DRM加载顺序

DRM驱动是由一系列相关功能模块的驱动的结合，它包含了vop、mipi、lvds、hdmi、edp、dp、backlight等等显示通路上的依赖模块。只有这些相互依赖的模块都加载完整，整个drm系统才算启动完成。

在DRM子系统中我们介绍了如何去抽象显示硬件到具体的DRM object；这里我们结合Rockchip平台以MIPI DSI显示接口为例来介绍显示硬件到具体的DRM object抽象，

object 说明
plane 图层；对Overlay硬件的抽象，同样需要访问Display Controller寄存器，因此也放在Display Controller驱动中
在Rockchip平台里对应SoC内部vop模块的win图层
crtc 显示控制器；RGB timing的产生，以及显示数据的更新，都需要访问Dislay Controller硬件寄存器，因此放在Display Controller驱动中
在Rockchip平台里对应SoC内部的vop模块
encoder 编码器；将RGB并行信号转换为DSI行信号，需要配置DSI硬件寄存器，因此放在DSI Controller驱动中
connector 连接器；可以通过drm_panel来获取LCD的mode信息，但是encoder在哪，connector就在哪，因此放在DSI Controller驱动中
drm_panel 用于获取LCD mode参数，并提供LCD休眠唤醒的回调接口，供encoder调用，因此放在LCD驱动中
bridge 桥接设备；一般用于注册encoder后面另外再接的转换芯片，如DSI2HDMI转换芯片

接下来我们将会以RK3399 DRM驱动为例对显示子系统的各个模块进行介绍；

驱动 文件清单
core drivers/gpu/drm/rockchip/rockchip_drm_drv.c
framebuffer drivers/gpu/drm/rockchip/rockchip_drm_fb.c
gem drivers/gpu/drm/rockchip/rockchip_drm_gem.c
vop drivers/gpu/drm/rockchip/rockchip_drm_vop.c
drivers/gpu/drm/rockchip/rockchip_vop_reg.c
drivers/gpu/drm/rockchip/rockchip_drm_vop2.c
drivers/gpu/drm/rockchip/rockchip_vop2_reg.c
lvds drivers/gpu/drm/rockchip/rockchip_lvds.c
rgb drivers/gpu/drm/rockchip/rockchip_rgb.c
mipi drivers/gpu/drm/rockchip/dw-mipi-dsi-rockchip.c
hdmi drivers/gpu/drm/rockchip/dw_hdmi-rockchip.c
drivers/gpu/drm/rockchip/inno_hdmi.c
edp drivers/gpu/drm/rockchip/analogix_dp-rockchip.c
drivers/gpu/drm/bridge/analogix/analogix_dp_core.c drivers/gpu/drm/bridge/analogix/analogix_dp_reg.c
dp drivers/gpu/drm/rockchip/cdn-dp-core.c
drivers/gpu/drm/rockchip/cdn-dp-reg.c

显示子系统各个模块驱动加载顺序如下图所示：

img

这里我们对驱动加载顺序图简单说明一下：

  • 在各种encoder driver和crtc driver的probe函数中：通过component_add将自己注册进系统；
  • 在Rockchip DRM Master driver的probe函数中；
    • 通过rockchip_drm_match_add为每个component（各种encoder和crtc ）注册一个component_match_array到component_match；
    • 通过component_master_add_with_match触发各种encoder和crtc component的bind操作，例如vop_bind、dw_hdmi_rockchip_bind等；
  • bind的含义就是将DRM框架里的组件关联在一起，以vop_bind为例：
    • VOP driver对应crtc driver，crtc 负责连接plane和encoder;
    • vop_create_crtc -> drm_crtc_init_with_planes初始化crtc对象，并和plane关联在一起;
  • 剩下的就是边边角角的工作，例如注册framebuffer以兼容FBDEV，显示logo等。

因为这些复杂的依赖关系，在DRM系统初始化的过程中，可能会出现某个资源暂时未就绪，而导致某个模块暂时无法顺利加载的情况。

为了解决这种问题，DRM驱动利用了Linux驱动中的deferred probe机制，当发现某个依赖的资源未就绪的时候，驱动返回-EPROBE_DEFER(-517) , 然后退出。Linux kernel会在稍后再次尝试加载这个驱动，直到依赖的资源就绪，驱动顺利加载为止。

二、设备树配置

在RK3399上，包含两个VOP、以及1个MIPI、1个DP、1个eDP、双通道MIPI DSI(4线/通道)显示接口；根据不用的显示屏，我们选择不同的模块来组成显示通路。具体使用那些模块，以及这些模块之间如何衔接通过dts配置。

2.1 display_subsystem设备节点

在每⼀个⽀持DRM显⽰功能的SoC的核⼼设备树⾥⾯，都会有display_subsystem节点：所有的子设备信息都通过设备树描述关联起来，这样系统开机后，就能统一的管理各个设备。

display_subsystem设备节点定义在arch/arm64/boot/dts/rockchip/rk3399.dtsi；

1
2
3
4
 display_subsystem: display-subsystem {
        compatible = "rockchip,display-subsystem";
        ports = <&vopl_out>, <&vopb_out>;
};

该节点描述的是Rockchip DRM主设备，也就是我们在component框架中介绍的aggregate_device ，这是一个虚拟设备，用于列出组成图形子系统的所有vop设备或其他显示接口节点。该设备节点对应的驱动代码位于drivers/gpu/drm/rockchip/rockchip_drm_drv.c。

其中ports属性描述vop硬件资源，列出了指向各个vop设备的phandle，vopl_out、vopb_out对应着VOP_LITE、VOP_BIG。

更多属性信息可以参考：

  • Documentation/devicetree/bindings/display/rockchip/rockchip-drm.yaml；
  • Documentation/devicetree/bindings/display/rockchip/rockchip-vop.yaml。

2.2 vop设备节点

vop设备节点描述了vop硬件资源，控制vop驱动的加载rockchip_drm_vop.c、 rockchip_drm_vop2.c。

以设备节点vopb_out为例，vopb_out设备节点定义在arch/arm64/boot/dts/rockchip/rk3399.dtsi;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
vopb: vop@ff900000 {
        compatible = "rockchip,rk3399-vop-big";
        reg = <0x0 0xff900000 0x0 0x2000>, <0x0 0xff902000 0x0 0x1000>;
        interrupts = <GIC_SPI 118 IRQ_TYPE_LEVEL_HIGH 0>;
        assigned-clocks = <&cru ACLK_VOP0>, <&cru HCLK_VOP0>;
        assigned-clock-rates = <400000000>, <100000000>;
        clocks = <&cru ACLK_VOP0>, <&cru DCLK_VOP0>, <&cru HCLK_VOP0>;
        clock-names = "aclk_vop", "dclk_vop", "hclk_vop";
        iommus = <&vopb_mmu>;
        power-domains = <&power RK3399_PD_VOPB>;
        resets = <&cru SRST_A_VOP0>, <&cru SRST_H_VOP0>, <&cru SRST_D_VOP0>;
        reset-names = "axi", "ahb", "dclk";
        status = "disabled";

        vopb_out: port {
                #address-cells = <1>;
                #size-cells = <0>;

                vopb_out_edp: endpoint@0 {
                        reg = <0>;
                        remote-endpoint = <&edp_in_vopb>;
                };

                vopb_out_mipi: endpoint@1 {
                        reg = <1>;
                        remote-endpoint = <&mipi_in_vopb>;
                };

                vopb_out_hdmi: endpoint@2 {
                        reg = <2>;
                        remote-endpoint = <&hdmi_in_vopb>;
                };

                vopb_out_mipi1: endpoint@3 {
                        reg = <3>;
                        remote-endpoint = <&mipi1_in_vopb>;
                };

                vopb_out_dp: endpoint@4 {
                        reg = <4>;
                        remote-endpoint = <&dp_in_vopb>;
                };
        };
};

子节点port下的endpoint描述的是vop和显示接口的连接关系，vopb_out节点下有vopb_out_edp，vopb_out_mipi，vopb_out_hdmi，vopb_out_mipi1、vopb_out_dp五个节点，说明vopb可以和mipi dsi0、edp、hdmi、mipi dsi1、dp五个显示接口连接。

每个endpoint通过remote-endpoint属性和对应的显示接口组成一个连接通路，例如vopb_out_hdmi —> hdmi_in_vopb。

设备节点vopl_out同理，这里就不在介绍了；

2.3 内核配置

make menuconfig配置内核：

1
2
3
4
5
6
7
8
9
10
11
12
13
Device Drivers --->
  Graphics support --->
        <*> Direct Rendering Manager (XFree86 4.1.0 and higher DRI support)  ---> 
       <*>  DRM Support for Rockchip (DRM_ROCKCHIP [=y])     
     [*]   Rockchip VOP driver
     [ ]   Rockchip VOP2 driver
     [*]   Rockchip specific extensions for Analogix DP driver  (ROCKCHIP_ANALOGIX_DP [=y]) 
     [*]   Rockchip cdn DP
     [*]   Rockchip specific extensions for Synopsys DW HDMI 
     [*]   Rockchip specific extensions for Synopsys DW MIPI DSI
     [*]   Rockchip specific extensions for Innosilicon HDMI
     [*]   Rockchip LVDS support
     [ ]   Rockchip RGB support

三、DRM驱动入口

DRM驱动模块入口函数为rockchip_drm_init，位于drivers/gpu/drm/rockchip/rockchip_drm_drv.c；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#define ADD_ROCKCHIP_SUB_DRIVER(drv, cond) { \
        if (IS_ENABLED(cond) && \
            !WARN_ON(num_rockchip_sub_drivers >= MAX_ROCKCHIP_SUB_DRIVERS)) \
                rockchip_sub_drivers[num_rockchip_sub_drivers++] = &drv; \
}

static int __init rockchip_drm_init(void)
{
        int ret;

        if (drm_firmware_drivers_only())
                return -ENODEV;

        // 1. 根据配置来决定是否添加xxx_xxx_driver到数组rockchip_sub_drivers
        num_rockchip_sub_drivers = 0;
        ADD_ROCKCHIP_SUB_DRIVER(vop_platform_driver, CONFIG_ROCKCHIP_VOP);
        ADD_ROCKCHIP_SUB_DRIVER(vop2_platform_driver, CONFIG_ROCKCHIP_VOP2);
        ADD_ROCKCHIP_SUB_DRIVER(rockchip_lvds_driver,
                                CONFIG_ROCKCHIP_LVDS);
        ADD_ROCKCHIP_SUB_DRIVER(rockchip_dp_driver,
                                CONFIG_ROCKCHIP_ANALOGIX_DP);
        ADD_ROCKCHIP_SUB_DRIVER(cdn_dp_driver, CONFIG_ROCKCHIP_CDN_DP);
        ADD_ROCKCHIP_SUB_DRIVER(dw_hdmi_rockchip_pltfm_driver,
                                CONFIG_ROCKCHIP_DW_HDMI);
        ADD_ROCKCHIP_SUB_DRIVER(dw_mipi_dsi_rockchip_driver,
                                CONFIG_ROCKCHIP_DW_MIPI_DSI);
        ADD_ROCKCHIP_SUB_DRIVER(inno_hdmi_driver, CONFIG_ROCKCHIP_INNO_HDMI);
        ADD_ROCKCHIP_SUB_DRIVER(rk3066_hdmi_driver,
                                CONFIG_ROCKCHIP_RK3066_HDMI);

        // 2. 注册多个platform driver    
        ret = platform_register_drivers(rockchip_sub_drivers,
                                        num_rockchip_sub_drivers);
        if (ret)
                return ret;

        // 3. 注册rockchip_drm_platform_driver
        ret = platform_driver_register(&rockchip_drm_platform_driver);
        if (ret)
                goto err_unreg_drivers;

        return 0;

err_unreg_drivers:
        platform_unregister_drivers(rockchip_sub_drivers,
                                    num_rockchip_sub_drivers);
        return ret;
}


module_init(rockchip_drm_init);

(1) 函数内部多次调用宏ADD_ROCKCHIP_SUB_DRIVER，完成vop、以及显示接口（lvds、dp、hdmi、mipi dsi）的添加。

咱们以hdmi如下代码为例；

1
2
ADD_ROCKCHIP_SUB_DRIVER(dw_hdmi_rockchip_pltfm_driver,
            CONFIG_ROCKCHIP_DW_HDMI);

展开得到：

1
2
3
if (IS_ENABLED(CONFIG_ROCKCHIP_DW_HDMI) && 
   !WARN_ON(num_rockchip_sub_drivers >= MAX_ROCKCHIP_SUB_DRIVERS)) 
      rockchip_sub_drivers[num_rockchip_sub_drivers++] = &dw_hdmi_rockchip_pltfm_driver;

如果定义了CONFIG_ROCKCHIP_DW_HDMI，会将dw_hdmi_rockchip_pltfm_driver保存到rockchip_sub_drivers数组中。

1
2
3
#define MAX_ROCKCHIP_SUB_DRIVERS 16
// 数组长度为16
static struct platform_driver *rockchip_sub_drivers[MAX_ROCKCHIP_SUB_DRIVERS];

那么宏CONFIG_ROCKCHIP_DW_HDMI到底是什么呢？

1
2
root@zhengyang:/work/sambashare/rk3399/linux-6.3# grep "CONFIG_ROCKCHIP_DW_HDMI" drivers/gpu/* -nR
drivers/gpu/drm/rockchip/Makefile:13:rockchipdrm-$(CONFIG_ROCKCHIP_DW_HDMI) += dw_hdmi-rockchip.o

可以看到宏CONFIG_ROCKCHIP_DW_HDMI决定了是否将dw_hdmi-rockchip.c编译到内核。

有关vop、以及显示接口（lvds、dp、hdmi、mipi dsi）的驱动咱们在后面章节单独介绍。

（2）调用platform_register_drivers注册num_rockchip_sub_drivers个platform driver；该函数内部遍历rockchip_sub_drivers数组，多次调用platform_driver_register注册platform driver，函数定义在drivers/base/platform.c；

(3) 最后调用platform_driver_register注册rockchip_drm_platform_driver。

3.1 rockchip_drm_platform_driver

dw_hdmi_rockchip_pltfm_driver定义在drivers/gpu/drm/rockchip/rockchip_drm_drv.c；

1
2
3
4
5
6
7
8
9
10
static struct platform_driver rockchip_drm_platform_driver = {
        .probe = rockchip_drm_platform_probe,
        .remove = rockchip_drm_platform_remove,
        .shutdown = rockchip_drm_platform_shutdown,
        .driver = {
                .name = "rockchip-drm",
                .of_match_table = rockchip_drm_dt_ids,
                .pm = &rockchip_drm_pm_ops,
        },
};
3.1.1 of_match_table

其中of_match_table用于设备树匹配，匹配设备树中compatible = "rockchip,display-subsystem"的设备节点；

1
2
3
4
static const struct of_device_id rockchip_drm_dt_ids[] = {
        { .compatible = "rockchip,display-subsystem", },
        { /* sentinel */ },
};
3.1.2 rockchip_drm_platform_probe

在plaftrom总线设备驱动模型中，我们知道当内核中有platform设备和platform驱动匹配，会调用到platform_driver里的成员.probe，在这里就是rockchip_drm_platform_probe函数；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
static const struct component_master_ops rockchip_drm_ops = {
        .bind = rockchip_drm_bind,
        .unbind = rockchip_drm_unbind,
};

// 校验display-subsystem设备节点的属性ports是否有效
static int rockchip_drm_platform_of_probe(struct device *dev)
{
        struct device_node *np = dev->of_node;
        struct device_node *port;
        bool found = false;
        int i;

        if (!np)
                return -ENODEV;

        for (i = 0;; i++) {
                // 获取ports属性第i个元素指向的设备节点
                // 例如：ports = <&vopl_out>, <&vopb_out> 保存了指向vop设备的phandle，返回指向设备节点的指针
                port = of_parse_phandle(np, "ports", i);
                if (!port)
                        break;

                // port的父设备节点存在，则不会进入
                if (!of_device_is_available(port->parent)) {
                        of_node_put(port);
                        continue;
                }

                // 设置为true
                found = true;
                of_node_put(port);
        }

        if (i == 0) {
                DRM_DEV_ERROR(dev, "missing 'ports' property\n");
                return -ENODEV;
        }

        if (!found) {
                DRM_DEV_ERROR(dev,
                              "No available vop found for display-subsystem.\n");
                return -ENODEV;
        }

        return 0;
}


static int rockchip_drm_platform_probe(struct platform_device *pdev)
{
        struct device *dev = &pdev->dev;
        struct component_match *match = NULL;
        int ret;


        // 校验display-subsystem设备节点的属性ports是否有效
        ret = rockchip_drm_platform_of_probe(dev);
        if (ret)
                return ret;

        // 构建一个带release函数的component_match
        match = rockchip_drm_match_add(dev);
        if (IS_ERR(match))
                return PTR_ERR(match);

        // 向系统注册一个aggregate_device,触发执行rockchip_drm_ops.bind，即rockchip_drm_bind
        ret = component_master_add_with_match(dev, &rockchip_drm_ops, match);
        if (ret < 0) {
                rockchip_drm_match_remove(dev);
                return ret;
        }

        return 0;
}

(1) 这里代码很简单，首先使用rockchip_drm_match_add来构建一个带release函数的component_match；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
static struct component_match *rockchip_drm_match_add(struct device *dev)
{
        struct component_match *match = NULL;
        int i;
    
        // 循环遍历
        for (i = 0; i < num_rockchip_sub_drivers; i++) {
                // 获取第i个platform_driver
                struct platform_driver *drv = rockchip_sub_drivers[i];
                struct device *p = NULL, *d;

                do {
                        d = platform_find_device_by_driver(p, &drv->driver);
                        put_device(p);
                        p = d;

                        if (!d)
                                break;

                        device_link_add(dev, d, DL_FLAG_STATELESS);
                        // component_match注册
                        component_match_add(dev, &match, component_compare_dev, d);
                } while (true);
        }

        if (IS_ERR(match))
                rockchip_drm_match_remove(dev);

        return match ?: ERR_PTR(-ENODEV);
}

(2) 最后为设备pdev->dev向系统注册一个aggregate_device，其中系统可执行的初始化操作被设置为了rockchip_drm_ops，我们需要重点关注bind函数的实现，即rockchip_drm_bind，这个我们单独小节介绍。

3.2 rockchip_drm_bind

我们定位到drivers/gpu/drm/rockchip/rockchip_drm_drv.c文件的函数rockchip_drm_bind，该函数用于绑定设备并初始化DRM驱动；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
static int rockchip_drm_bind(struct device *dev)
{
        struct drm_device *drm_dev;
        struct rockchip_drm_private *private;
        int ret;

        /* 1. Remove existing drivers that may own the framebuffer memory. */
        ret = drm_aperture_remove_framebuffers(false, &rockchip_drm_driver);
        if (ret) {
                DRM_DEV_ERROR(dev,
                              "Failed to remove existing framebuffers - %d.\n",
                              ret);
                return ret;
        }

        // 2. 动态分配并初始化struct drm_device实例
        drm_dev = drm_dev_alloc(&rockchip_drm_driver, dev); 
        if (IS_ERR(drm_dev))
                return PTR_ERR(drm_dev);

        // 3. 设置drm设备驱动私有数据为drm设备
        dev_set_drvdata(dev, drm_dev); 

        // 4. 动态分配rockchip_drm_private
        private = devm_kzalloc(drm_dev->dev, sizeof(*private), GFP_KERNEL); 
        if (!private) {
                ret = -ENOMEM;
                goto err_free;
        }

        drm_dev->dev_private = private;  

        // 5. 初始化drm_device中mode_config结构体
        ret = drmm_mode_config_init(drm_dev); 
        if (ret)
                goto err_free;

        // 初始化drm_device中mode_config的中成员
        rockchip_drm_mode_config_init(drm_dev);

        /* 6. Try to bind all sub drivers. 执行按顺序执行显示子系统的各个组件的bind函数 */
        ret = component_bind_all(dev, drm_dev);
        if (ret)
                goto err_free;

        // 7. 初始化IOMMU
        ret = rockchip_drm_init_iommu(drm_dev);
        if (ret)
                goto err_unbind_all;

        // 8.初始化vblank
        ret = drm_vblank_init(drm_dev, drm_dev->mode_config.num_crtc);
        if (ret)
                goto err_iommu_cleanup;

        // 9. 重置模式配置
        drm_mode_config_reset(drm_dev);

        /* 10.init kms poll for handling hpd */
        drm_kms_helper_poll_init(drm_dev);

        // 11.注册drm设备
        ret = drm_dev_register(drm_dev, 0); 
        if (ret)
                goto err_kms_helper_poll_fini;

        // 12.设置帧缓冲设备
        drm_fbdev_generic_setup(drm_dev, 0);

        return 0;
err_kms_helper_poll_fini:
        drm_kms_helper_poll_fini(drm_dev);
err_iommu_cleanup:
        rockchip_iommu_cleanup(drm_dev);
err_unbind_all:
        component_unbind_all(dev, drm_dev);
err_free:
        drm_dev_put(drm_dev);
        return ret;
}

函数主要步骤如下：

(1) 首先，通过调用drm_aperture_remove_framebuffers函数，移除可能拥有framebuffer memory的现有驱动程序；

为什么要执行这个操作呢？对于一个图形设备来说，可能有多个驱动程序提供支持，但在任何给定的事件只能有一个驱动程序处于活动状态。许多系统在引导过程的早期加载通用图形驱动程序，例如EFI-GOP或VESA，在后续的引导阶段，它们会将通用驱动程序替换为专用的、针对具体硬件的驱动程序。为了接管该设备，专用驱动程序首先必须移除通用驱动程序。DRM aperture函数负责管理DRM framebuffer内存的所有权和驱动程序之间的交接；

更多内容可以参考：Managing Ownership of the Framebuffer Aperture。

(2) 接下来，使用drm_dev_alloc函数为设备动态分配和初始化一个struct drm_device结构体，并将其保存在drm_dev指针中，其driver被设置为rockchip_drm_driver；

1
drm_dev = drm_dev_alloc(&rockchip_drm_driver, dev);

(3) 然后，使用dev_set_drvdata函数将设备的驱动私有数据设置为drm_dev；

1
dev_set_drvdata(dev, drm_dev);

(4) 使用devm_kzalloc函数为drm_dev动态分配一个rockchip_drm_private结构体，并将其保存在drm_dev->dev_private指针中；

1
private = devm_kzalloc(drm_dev->dev, sizeof(*private), GFP_KERNEL)

(5) 调用drmm_mode_config_init函数和rockchip_drm_mode_config_init函数对drm_dev进行模式配置的初始化；

(6) 调用component_bind_all函数，执行按顺序执行显示子系统的各个组件的bind函数；

(7) 调用rockchip_drm_init_iommu函数初始化IOMMU；

(8) 调用drm_vblank_init函数初始化vblank；

(9) 调用drm_mode_config_reset函数重置模式配置；

(10) 调用drm_kms_helper_poll_init函数初始化KMS轮询以处理HPD（Hot Plug Detect）；

(11) 在所有准备工作都完成后，调用drm_dev_register函数注册DRM设备；

(12) 调用drm_fbdev_generic_setup函数设置帧缓冲设备；

3.2.1 初始化drm设备

一个drm驱动的设备由struct drm_device来表示，这里调用drm_dev_alloc进行分配和初始化一个struct drm_device实例，其driver被设置为rockchip_drm_driver，有关rockchip_drm_driver单独小节介绍。

drm_dev_alloc函数定义在drivers/gpu/drm/drm_drv.c；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/**
 * drm_dev_alloc - Allocate new DRM device
 * @driver: DRM driver to allocate device for
 * @parent: Parent device object
 *
 * This is the deprecated version of devm_drm_dev_alloc(), which does not support
 * subclassing through embedding the struct &drm_device in a driver private
 * structure, and which does not support automatic cleanup through devres.
 *
 * RETURNS:
 * Pointer to new DRM device, or ERR_PTR on failure.
 */
struct drm_device *drm_dev_alloc(const struct drm_driver *driver,
                                 struct device *parent)
{
        struct drm_device *dev;
        int ret;

        // 动态分配一个struct drm_device 
        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
        if (!dev)
                return ERR_PTR(-ENOMEM);

        // 初始化drm_device
        ret = drm_dev_init(dev, driver, parent);
        if (ret) {
                kfree(dev);
                return ERR_PTR(ret);
        }

        drmm_add_final_kfree(dev, dev);

        return dev;
}

drm_dev_alloc函数时一个已废弃版本，它不支持在驱动程序的私有结构中嵌入struct drm_device来实现子类化，并且不支持通过devres进行自动清理。

drm_dev_alloc函数内部调用drm_dev_init去初始化struct drm_device实例。

3.2.2 模式配置初始化

下面我们分析一下drmm_mode_config_init函数和rockchip_drm_mode_config_init函数；

1
2
3
4
5
6
7
8
// 调用drm_mode_config_init初始化drm_device中mode_config
ret = drmm_mode_config_init(drm_dev);
if (ret)
    goto err_free;

// 填充mode_config中min_width, min_height、max_width, max_height的值，这些值是framebuffer的大小限制
// 设置mode_config->funcs指针，本质是一组由驱动实现的回调函数
rockchip_drm_mode_config_init(drm_dev);

rockchip_drm_mode_config_init函数定义在drivers/gpu/drm/rockchip/rockchip_drm_fb.c，内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void rockchip_drm_mode_config_init(struct drm_device *dev)
{
        dev->mode_config.min_width = 0;
        dev->mode_config.min_height = 0;

        /*
         * set max width and height as default value(4096x4096).
         * this value would be used to check framebuffer size limitation
         * at drm_mode_addfb().
         */
        dev->mode_config.max_width = 4096;  // 设备上支持的最大帧缓冲区像素高度
        dev->mode_config.max_height = 4096; // 设备上支持的最大帧缓冲区像素高度

        dev->mode_config.funcs = &rockchip_drm_mode_config_funcs;
        dev->mode_config.helper_private = &rockchip_mode_config_helpers;

        dev->mode_config.normalize_zpos = true;
}

（1） drm显示器模式设置mode_config回调函数funcs被设置为rockchip_drm_mode_config_funcs；

1
2
3
4
5
static const struct drm_mode_config_funcs rockchip_drm_mode_config_funcs = {
        .fb_create = rockchip_fb_create,
        .atomic_check = drm_atomic_helper_check,
        .atomic_commit = drm_atomic_helper_commit,
};

fb_create 回调接口用于创建framebuffer object，该函数我们在后面GEM章节单独介绍。

(2) drm显示器模式设置mode_config中间层私有数据helper_private被设置为了rockchip_mode_config_helpers；

1
2
3
static const struct drm_mode_config_helper_funcs rockchip_mode_config_helpers = {
        .atomic_commit_tail = drm_atomic_helper_commit_tail_rpm,
};
3.2.3 component_bind_all

在component_bind_all函数我们已经在《Rockchip RK3399 - component框架》详细介绍了；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/**
 * component_bind_all - bind all components of an aggregate driver
 * @parent: parent device of the aggregate driver
 * @data: opaque pointer, passed to all components
 *
 * Binds all components of the aggregate @dev by passing @data to their
 * &component_ops.bind functions. Should be called from
 * &component_master_ops.bind.
 */
int component_bind_all(struct device *parent, void *data)
{
        struct aggregate_device *adev;
        struct component *c;
        size_t i;
        int ret = 0;

        WARN_ON(!mutex_is_locked(&component_mutex));

        // 根据parent查找到aggregate_device
        adev = __aggregate_find(parent, NULL);
        if (!adev)
                return -EINVAL;

        /* Bind components in match order */
        for (i = 0; i < adev->match->num; i++)
                // duplicate为false时进入
                if (!adev->match->compare[i].duplicate) {
                        c = adev->match->compare[i].component;
                        // 执行component的bind函数
                        ret = component_bind(c, adev, data);
                        if (ret)
                                break;
                }

        if (ret != 0) { // 正常不会走这里
                for (; i > 0; i--)
                        if (!adev->match->compare[i - 1].duplicate) {
                                c = adev->match->compare[i - 1].component;
                                component_unbind(c, adev, data);
                        }
        }

        return ret;
}

首先通过设备parent找到与之关联的的aggregate_device，再按照aggregate_device→component_match_array→component的顺序找到component，然后就能调用component的bind函数。

3.2.4 注册drm设备

最后调用drm_dev_register注册drm设备。

四、rockchip_drm_driver

接下来我们以源码rockchip_drm_drv.c中的rockchip_drm_driver全局变量作为切入点进行介绍；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
static const struct drm_driver rockchip_drm_driver = {
        .driver_features        = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
        .dumb_create            = rockchip_gem_dumb_create,
        .prime_handle_to_fd     = drm_gem_prime_handle_to_fd,
        .prime_fd_to_handle     = drm_gem_prime_fd_to_handle,
        .gem_prime_import_sg_table      = rockchip_gem_prime_import_sg_table,
        .gem_prime_mmap         = drm_gem_prime_mmap,
        .fops                   = &rockchip_drm_driver_fops,
        .name   = DRIVER_NAME,
        .desc   = DRIVER_DESC,
        .date   = DRIVER_DATE,
        .major  = DRIVER_MAJOR,
        .minor  = DRIVER_MINOR,
};

4.1 driver_features

  • 添加上 DRIVER_GEM 标志位，告诉DRM Core该驱动支持GEM操作；
  • 添加上 DRIVER_MODESET 标志位，告诉DRM Core 该驱动支持kernel Mode Setting操作；
  • 添加上 DRIVER_ATOMIC 标志位，告诉 DRM Core该驱动支持Atomic操作。

4.2 宏变量

1
2
3
4
5
#define DRIVER_NAME     "rockchip"
#define DRIVER_DESC     "RockChip Soc DRM"
#define DRIVER_DATE     "20140818"
#define DRIVER_MAJOR    1
#define DRIVER_MINOR    0

4.3 dumb_create

其中dumb_create配置为rockchip_gem_dumb_create，该函数用于分配物理内存dumb buffer，gem相关的内容后面我们单独章节介绍。

4.4、DRM设备节点文件操作集

DRM驱动程序必须定义文件操作结构，形成DRM用户空间API的入口点，在rockchip_drm_driver中将DRM设备节点文件操作集fops设置为rockchip_drm_driver_fops，内容如下：

1
DEFINE_DRM_GEM_FOPS(rockchip_drm_driver_fops);

DEFINE_DRM_GEM_FOPS宏定义在include/drm/drm_gem.h：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/**
 * DRM_GEM_FOPS - Default drm GEM file operations
 *
 * This macro provides a shorthand for setting the GEM file ops in the
 * &file_operations structure.  If all you need are the default ops, use
 * DEFINE_DRM_GEM_FOPS instead.
 */
#define DRM_GEM_FOPS \
        .open           = drm_open,\
        .release        = drm_release,\
        .unlocked_ioctl = drm_ioctl,\
        .compat_ioctl   = drm_compat_ioctl,\
        .poll           = drm_poll,\
        .read           = drm_read,\
        .llseek         = noop_llseek,\
        .mmap           = drm_gem_mmap

/**
 * DEFINE_DRM_GEM_FOPS() - macro to generate file operations for GEM drivers
 * @name: name for the generated structure
 *
 * This macro autogenerates a suitable &struct file_operations for GEM based
 * drivers, which can be assigned to &drm_driver.fops. Note that this structure
 * cannot be shared between drivers, because it contains a reference to the
 * current module using THIS_MODULE.
 *
 * Note that the declaration is already marked as static - if you need a
 * non-static version of this you're probably doing it wrong and will break the
 * THIS_MODULE reference by accident.
 */
#define DEFINE_DRM_GEM_FOPS(name) \
        static const struct file_operations name = {\
                .owner          = THIS_MODULE,\
                DRM_GEM_FOPS,\
        }

宏展开后得到：

1
2
3
4
5
6
7
8
9
10
11
static const struct file_operations rockchip_drm_driver_fops = {
        .owner          = THIS_MODULE,
        .open           = drm_open,
        .release        = drm_release,
        .unlocked_ioctl = drm_ioctl,
        .compat_ioctl   = drm_compat_ioctl,
        .poll           = drm_poll,
        .read           = drm_read,
        .llseek         = noop_llseek,
        .mmap           = drm_gem_mmap
}

强制要求的函数是drm_open、drm_read、drm_ioctl和drm_compat_ioctl（如果启用了CONFIG_COMPAT）；
drm_read和drm_poll提供了对DRM事件的支持。DRM事件是一种通用且可扩展的方式，通过文件描述符向用户空间发送异步事件。它们用于通过KMS API发送vblank事件和页面翻转完成事件。但是驱动程序也可以根据自己的需求使用它，例如用于信号渲染完成。
内存映射的实现方式将根据驱动程序如何管理内存而有所不同：

  • 过时驱动程序将使用drm_legacy_mmap函数；
  • 现代驱动程序应该使用提供的特定于内存管理器的实现之一；对于基于GEM的驱动程序，可以使用drm_gem_mmap。
4.4.1 drm_open

在上一篇博客中，我们说过当打开一个drm设备时，比如/dev/dri/card0，最终回调用drm driver的文件操作集fops中的open函数，即drm_open；drm_open函数定义在drivers/gpu/drm/drm_file.c；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/**
 * drm_open - open method for DRM file
 * @inode: device inode
 * @filp: file pointer.
 *
 * This function must be used by drivers as their &file_operations.open method.
 * It looks up the correct DRM device and instantiates all the per-file
 * resources for it. It also calls the &drm_driver.open driver callback.
 *
 * RETURNS:
 *
 * 0 on success or negative errno value on failure.
 */
int drm_open(struct inode *inode, struct file *filp)
{
        struct drm_device *dev;
        struct drm_minor *minor;
        int retcode;
        int need_setup = 0;

        // 根据设备节点获取struct drm_minor
        minor = drm_minor_acquire(iminor(inode));
        if (IS_ERR(minor))
                return PTR_ERR(minor);

        // 获取drm device
        dev = minor->dev;
        if (drm_dev_needs_global_mutex(dev))
                mutex_lock(&drm_global_mutex);

        if (!atomic_fetch_inc(&dev->open_count))
                need_setup = 1;

        /* share address_space across all char-devs of a single device */
        filp->f_mapping = dev->anon_inode->i_mapping;

        // 调用drm open helper函数
        retcode = drm_open_helper(filp, minor);
        if (retcode)
                goto err_undo;
        if (need_setup) {
                retcode = drm_legacy_setup(dev);
                if (retcode) {
                        drm_close_helper(filp);
                        goto err_undo;
                }
        }

        if (drm_dev_needs_global_mutex(dev))
                mutex_unlock(&drm_global_mutex);

        return 0;

err_undo:
        atomic_dec(&dev->open_count);
        if (drm_dev_needs_global_mutex(dev))
                mutex_unlock(&drm_global_mutex);
        drm_minor_release(minor);
        return retcode;
}

这里核心实现为drm_open_helper；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
/*
 * Called whenever a process opens a drm node
 *
 * \param filp file pointer.
 * \param minor acquired minor-object.
 * \return zero on success or a negative number on failure.
 *
 * Creates and initializes a drm_file structure for the file private data in \p
 * filp and add it into the double linked list in \p dev.
 */
int drm_open_helper(struct file *filp, struct drm_minor *minor)
{
        struct drm_device *dev = minor->dev;
        struct drm_file *priv;
        int ret;

        if (filp->f_flags & O_EXCL)
                return -EBUSY;  /* No exclusive opens */
        if (!drm_cpu_valid())
                return -EINVAL;
        if (dev->switch_power_state != DRM_SWITCH_POWER_ON &&
            dev->switch_power_state != DRM_SWITCH_POWER_DYNAMIC_OFF)
                return -EINVAL;

        drm_dbg_core(dev, "comm=\"%s\", pid=%d, minor=%d\n",
                     current->comm, task_pid_nr(current), minor->index);

        // 动态分配并初始化struct drm_file
        priv = drm_file_alloc(minor);
        if (IS_ERR(priv))
                return PTR_ERR(priv);

        if (drm_is_primary_client(priv)) {
                ret = drm_master_open(priv);
                if (ret) {
                        drm_file_free(priv);
                        return ret;
                }
        }

        // 保存为file的私有数据
        filp->private_data = priv;
        filp->f_mode |= FMODE_UNSIGNED_OFFSET;
        priv->filp = filp;

        mutex_lock(&dev->filelist_mutex);
        list_add(&priv->lhead, &dev->filelist);
        mutex_unlock(&dev->filelist_mutex);
        return 0;
}
4.4.2 内存映射

mmap用于将物理内存dumb buffer映射到用户空间，让应用程序可以直接访问物理内存。
drm_gem_mmap函数定义在drivers/gpu/drm/drm_gem.c，内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
/**
 * drm_gem_mmap - memory map routine for GEM objects
 * @filp: DRM file pointer
 * @vma: VMA for the area to be mapped
 *
 * If a driver supports GEM object mapping, mmap calls on the DRM file
 * descriptor will end up here.
 *
 * Look up the GEM object based on the offset passed in (vma->vm_pgoff will
 * contain the fake offset we created when the GTT map ioctl was called on
 * the object) and map it with a call to drm_gem_mmap_obj().
 *
 * If the caller is not granted access to the buffer object, the mmap will fail
 * with EACCES. Please see the vma manager for more information.
 */
int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
{
        struct drm_file *priv = filp->private_data;
        struct drm_device *dev = priv->minor->dev;
        struct drm_gem_object *obj = NULL;
        struct drm_vma_offset_node *node;
        int ret;

        // 检查drm设备是否已被拔出
        if (drm_dev_is_unplugged(dev))
                return -ENODEV;

        // 锁定VMA管理器
        drm_vma_offset_lock_lookup(dev->vma_offset_manager);
        node = drm_vma_offset_exact_lookup_locked(dev->vma_offset_manager,
                                                  vma->vm_pgoff,
                                                  vma_pages(vma));
        if (likely(node)) {
                obj = container_of(node, struct drm_gem_object, vma_node);
                /*
                 * When the object is being freed, after it hits 0-refcnt it
                 * proceeds to tear down the object. In the process it will
                 * attempt to remove the VMA offset and so acquire this
                 * mgr->vm_lock.  Therefore if we find an object with a 0-refcnt
                 * that matches our range, we know it is in the process of being
                 * destroyed and will be freed as soon as we release the lock -
                 * so we have to check for the 0-refcnted object and treat it as
                 * invalid.
                 */
                if (!kref_get_unless_zero(&obj->refcount))
                        obj = NULL;
        }
        // 解锁VMA管理器
        drm_vma_offset_unlock_lookup(dev->vma_offset_manager);

        if (!obj)
                return -EINVAL;

        if (!drm_vma_node_is_allowed(node, priv)) {
                drm_gem_object_put(obj);
                return -EACCES;
        }

        // Set up the VMA to prepare mapping of the GEM object using the GEM object's vm_ops
        ret = drm_gem_mmap_obj(obj, drm_vma_node_size(node) << PAGE_SHIFT,
                               vma);

        // GEM对象引用计数-1
        drm_gem_object_put(obj);

        return ret;
}

参考文章

[1] DRM (Direct Rendering Manager)

[2] linux Display driver example

[3] Linux DRM那些事-component bind解析

[4] DRM Display Driver Guide

[5] rockchip中的vop

[6] RK3399探索之旅/Display子系统/基础概念

[7] Linux MIPI DSI驱动开发 | 基于RK3399

[8] DRM驱动（一）之显示处理器介绍