显示系统的主流框架：DRM和FB框架

最新推荐文章于 2024-04-26 16:31:32 发布
最新推荐文章于 2024-04-26 16:31:32 发布
阅读量1k 收藏 32
点赞数 11
文章标签： linux arm 驱动开发 stm32 物联网
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/apple_71040140/article/details/136350724
版权

前言：

显示系统的主流框架有哪些？有啥区别 ？各自有啥优缺点？ 

    在 Linux 系统中，主流的显示框架有两种： DRM(Direct Rendering Module)框架和
FB(FrameBuffer)框架。FB 框架不能处理基于 3D 加速 GPU 显卡，DRM 是可以统一管理 GPU
显示，所以 DRM 相对于 FB 更能适应新的显示硬件。比如 DRM 支持多层合成、支持 VSYNC、
支持 DMA-BUF、支持 fence 机制等等。
一、FB框架：
FB框架是传统的显示框架，相对简单，但是只能提供最基础的显示功能;
无法满足当前上层应用和底层硬件的显示需求。

lcd显示器驱动其实争对是像素点，：整体概念如图：

    FrameBuffer驱动是一个字符设备，设备节点是/dev/fbX，主设备号为29，次设备号递增，
frambuffer就是linux内核驱动申请的一片内存空间，然后lcd内有一片sram，
cpu内部有个lcd控制器，它有个单独的dma用来将frambuffer中的数据拷贝到lcd的sram中去 
拷贝到lcd的sram中的数据就会显示在lcd上，LCD驱动负责把信号转成显示屏上的内容，
至于什么内容这就是应用层要处理的。

        假设每个像素的颜色用16位来表示，那么一个LCD的所有像素点假设有xres * y res个，
需要的内存为：xres * yres * 16 / 8，也就是要设置所有像素的颜色，需要这么大小的内存。
这块内存就被称为framebuffer， framebuffer字符驱动就是将lcd屏幕显示内存中写入对应颜色内容。

二、FB应用程序操作步骤：

应用程序操作步骤：
    1> 打开设备文件 /dev/fb0
    2> 获取当前设备信息 #include <linux/fb.h>
    3> mmap做映射
    4> 填充framebuffer

 FB驱动框架结构：

三、DRM框架
    目前主流的显示方案;为了适应当前日益更新的显示硬件;软件上能支持更多高级的控制和
特性FB框架不能处理基于3D加速GPU显卡，DRM是可以统一管理GPU显示，
所以DRM相对于FB更能适应新的显示硬件

         下图就是一个 DRM 驱动框架包括两部分：DRM core 和 DRM driver。DRM core 提供了一 个基本的 DRM 框架，DRM driver 就可以注册进 DRM 框架，同时为用户空间提供一组 ioctl。 libdrm 对底层接口(DRM driver 提供的 ioctl)进行封装，向上层提供统一的 API 接口。DRM driver 包含了 GEM 模块和 KMS 模块这两大模块，这两模块也分为好几个小模块。

 

    图形执行管理器(GEM)：全称 Graphics Execution Manager，这是一个内存管理器，主要负
责内存的分配和释放，可以调用 GPU。

    DUMB：这是一个 dumb 缓冲区，主要负责一些简单的 buffer 显示，可以通过 CPU 直接渲
染 dumb，GPU 不会使用 dumb。

    内核显示模式设置(KMS)：全称 Kernel Mode Setting，主要负责显示的控制，包括屏幕分辨
率、屏幕刷新率和颜色深度等等。

    CRTC：就是指显示控制器，在 DRM 里有多个显存，就可以通过操作 CRTC 来控制要显示
那个显存。

    Encoder（编码器）：负责从 CRTC 里输出的 timing 时序转换成外部设备所需要的信号的模块，同时也
负责控制 LCD 的显示。

    Connector（连接器）：连接物理显示设备的连接器，比如 DSI、HDMI 等等。

    Plane（面板）：负责获取显存，在输出到 CRTC 里，说明 CRTC 必须要有一个 Plane。每个图像拥有一个Planes，Planes的属性控制着图像的显示区域、图像翻转、色彩混合方式等， 最终图像经过Planes并通过CRTC，得到多个图像的混合显示或单独显示的等等功能

帧缓冲(FB)：能够显示图层的 buffer。

 

 

1、DRM driver模块：

GEM和KMS连接如下：

    蓝色框表示KMS里的模块,KMS：全称 Kernel Mode Setting，主要负责显示的控制，包括屏幕分辨率、
屏幕刷新率和颜色深度等等。
    plane是连接crtc和framebuffer的纽带，而encoder是连接crtc和connector的纽带
    GEM是负责和物理的buffer打交道不是framebuffer
plane把获取到显存输出到crtc里，crtc通过connector接口输出到显示器
2、DRM core模块：

      提供了一个DRM框架：

       
    在 Linux 系统中，DRM 驱动的核心主要就一个 drm_driver 结构体，驱动程序要初始化
drm_driver 结构体，然后调用 drm_dev_init 函数，将其注册到 DRM core。

        我们可以通过“drivers/gpu/drm/stm/drv.c”查看drm源码：

#include <linux/component.h>
#include <linux/dma-mapping.h>
#include <linux/module.h>
#include <linux/of_platform.h>
#include <linux/pm_runtime.h>

#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_drv.h>
#include <drm/drm_fb_cma_helper.h>
#include <drm/drm_fb_helper.h>
#include <drm/drm_gem_cma_helper.h>
#include <drm/drm_gem_framebuffer_helper.h>
#include <drm/drm_probe_helper.h>
#include <drm/drm_vblank.h>

#include "ltdc.h"

#define STM_MAX_FB_WIDTH	2048
#define STM_MAX_FB_HEIGHT	2048 /* same as width to handle orientation */

static const struct drm_mode_config_funcs drv_mode_config_funcs = {
	.fb_create = drm_gem_fb_create,
	.atomic_check = drm_atomic_helper_check,
	.atomic_commit = drm_atomic_helper_commit,
};

static int stm_gem_cma_dumb_create(struct drm_file *file,
				   struct drm_device *dev,
				   struct drm_mode_create_dumb *args)
{
	unsigned int min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);

	/*
	 * in order to optimize data transfer, pitch is aligned on
	 * 128 bytes, height is aligned on 4 bytes
	 */
	args->pitch = roundup(min_pitch, 128);
	args->height = roundup(args->height, 4);

	return drm_gem_cma_dumb_create_internal(file, dev, args);
}

DEFINE_DRM_GEM_CMA_FOPS(drv_driver_fops);

static struct drm_driver drv_driver = {
	.driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_ATOMIC,
	.name = "stm",
	.desc = "STMicroelectronics SoC DRM",
	.date = "20170330",
	.major = 1,
	.minor = 0,
	.patchlevel = 0,
	.fops = &drv_driver_fops,
	.dumb_create = stm_gem_cma_dumb_create,
	.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
	.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
	.gem_free_object_unlocked = drm_gem_cma_free_object,
	.gem_vm_ops = &drm_gem_cma_vm_ops,
	.gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table,
	.gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table,
	.gem_prime_vmap = drm_gem_cma_prime_vmap,
	.gem_prime_vunmap = drm_gem_cma_prime_vunmap,
	.gem_prime_mmap = drm_gem_cma_prime_mmap,
	.get_scanout_position = ltdc_crtc_scanoutpos,
	.get_vblank_timestamp = drm_calc_vbltimestamp_from_scanoutpos,
};

static int drv_load(struct drm_device *ddev)
{
	struct platform_device *pdev = to_platform_device(ddev->dev);
	struct ltdc_device *ldev;
	int ret;

	DRM_DEBUG("%s\n", __func__);

	ldev = devm_kzalloc(ddev->dev, sizeof(*ldev), GFP_KERNEL);
	if (!ldev)
		return -ENOMEM;

	ddev->dev_private = (void *)ldev;

	drm_mode_config_init(ddev);

	/*
	 * set max width and height as default value.
	 * this value would be used to check framebuffer size limitation
	 * at drm_mode_addfb().
	 */
	ddev->mode_config.min_width = 0;
	ddev->mode_config.min_height = 0;
	ddev->mode_config.max_width = STM_MAX_FB_WIDTH;
	ddev->mode_config.max_height = STM_MAX_FB_HEIGHT;
	ddev->mode_config.funcs = &drv_mode_config_funcs;

	ret = ltdc_load(ddev);
	if (ret)
		goto err;

	drm_mode_config_reset(ddev);
	drm_kms_helper_poll_init(ddev);

	platform_set_drvdata(pdev, ddev);

	return 0;
err:
	drm_mode_config_cleanup(ddev);
	return ret;
}

static void drv_unload(struct drm_device *ddev)
{
	DRM_DEBUG("%s\n", __func__);

	drm_kms_helper_poll_fini(ddev);
	ltdc_unload(ddev);
	drm_mode_config_cleanup(ddev);
}

static __maybe_unused int drv_suspend(struct device *dev)
{
	struct drm_device *ddev = dev_get_drvdata(dev);
	struct ltdc_device *ldev = ddev->dev_private;
	struct drm_atomic_state *state;

	WARN_ON(ldev->suspend_state);

	state = drm_atomic_helper_suspend(ddev);
	if (IS_ERR(state))
		return PTR_ERR(state);

	ldev->suspend_state = state;
	pm_runtime_force_suspend(dev);

	return 0;
}

static __maybe_unused int drv_resume(struct device *dev)
{
	struct drm_device *ddev = dev_get_drvdata(dev);
	struct ltdc_device *ldev = ddev->dev_private;
	int ret;

	if (WARN_ON(!ldev->suspend_state))
		return -ENOENT;

	pm_runtime_force_resume(dev);
	ret = drm_atomic_helper_resume(ddev, ldev->suspend_state);
	if (ret)
		pm_runtime_force_suspend(dev);

	ldev->suspend_state = NULL;

	return ret;
}

static __maybe_unused int drv_runtime_suspend(struct device *dev)
{
	struct drm_device *ddev = dev_get_drvdata(dev);

	DRM_DEBUG_DRIVER("\n");
	ltdc_suspend(ddev);

	return 0;
}

static __maybe_unused int drv_runtime_resume(struct device *dev)
{
	struct drm_device *ddev = dev_get_drvdata(dev);

	DRM_DEBUG_DRIVER("\n");
	return ltdc_resume(ddev);
}

static const struct dev_pm_ops drv_pm_ops = {
	SET_SYSTEM_SLEEP_PM_OPS(drv_suspend, drv_resume)
	SET_RUNTIME_PM_OPS(drv_runtime_suspend,
			   drv_runtime_resume, NULL)
};

static int stm_drm_platform_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct drm_device *ddev;
	int ret;

	DRM_DEBUG("%s\n", __func__);

	dma_set_coherent_mask(dev, DMA_BIT_MASK(32));

	ddev = drm_dev_alloc(&drv_driver, dev);
	if (IS_ERR(ddev))
		return PTR_ERR(ddev);

	ret = drv_load(ddev);
	if (ret)
		goto err_put;

	ret = drm_dev_register(ddev, 0);
	if (ret)
		goto err_put;

	drm_fbdev_generic_setup(ddev, 16);

	return 0;

err_put:
	drm_dev_put(ddev);

	return ret;
}

static int stm_drm_platform_remove(struct platform_device *pdev)
{
	struct drm_device *ddev = platform_get_drvdata(pdev);

	DRM_DEBUG("%s\n", __func__);

	drm_dev_unregister(ddev);
	drv_unload(ddev);
	drm_dev_put(ddev);

	return 0;
}

static const struct of_device_id drv_dt_ids[] = {    //匹配条件
	{ .compatible = "st,stm32-ltdc"},
	{ /* end node */ },
};
MODULE_DEVICE_TABLE(of, drv_dt_ids);

static struct platform_driver stm_drm_platform_driver = {
	.probe = stm_drm_platform_probe,
	.remove = stm_drm_platform_remove,
	.driver = {
		.name = "stm32-display",
		.of_match_table = drv_dt_ids,
		.pm = &drv_pm_ops,
	},
};

module_platform_driver(stm_drm_platform_driver);

MODULE_AUTHOR("Philippe Cornu <philippe.cornu@st.com>");
MODULE_AUTHOR("Yannick Fertre <yannick.fertre@st.com>");
MODULE_AUTHOR("Fabien Dessenne <fabien.dessenne@st.com>");
MODULE_AUTHOR("Mickael Reulier <mickael.reulier@st.com>");
MODULE_DESCRIPTION("STMicroelectronics ST DRM LTDC driver");
MODULE_LICENSE("GPL v2");

这是一个标准的平台总线文件：

1.1 当注册了平台总线后会调用一下结构体，执行函数：

1.2 自动进行匹配

1.3 当匹配成功时候会自动执行probe函数，当解除时会自动执行remove函数进行空间释放。

 1.4 probe函数是正常的进行基本的device设备操作。

 1.5 和其他设备驱动一样，DRM 也分为 DRM device和 DRM drive，drm_device 结构体为 DRM

设备， drm_driver 为 DRM 驱动，我们依次来看一下这两个结构体:
1.5.1drm_device结构体
   
struct drm_device {
  struct list_head legacy_dev_list;
  int if_version;
  struct kref ref;
  u32 max_vblank_count;
....
 struct list_head vblank_event_list;
 spinlock_t event_lock;
 struct drm_agp_head *agp;
 struct pci_dev *pdev;
 unsigned int num_crtcs;
 struct drm_mode_config mode_config;
 struct mutex object_name_lock;
 struct idr object_name_idr;
 struct drm_vma_offset_manager *vma_offset_manager;
 struct drm_vram_mm *vram_mm;
 enum switch_power_state switch_power_state;
 struct drm_fb_helper *fb_helper;
};
我们在编写 DRM 驱动的时候需要自行申请 drm_device 内存并且使用初始化，这个可以直
接通过 drm_dev_alloc 函数来完成，函数原型如下： 
struct drm_device *drm_dev_alloc(struct drm_driver *driver, struct device *parent)
此函数会先调用 kzalloc 为 drm_device 分配内存，然后调用 drm_dev_init 初始化 drm_device，
函数参数和返回值含义如下：

driver：drm_driver 结构体指针，也就是 DRM 设备对应的 DRM 驱动。 

parent：父设备。 

返回值：返回分配成功的新 DRM 设备，如果返回 ERR_PTR 的话就表示 drm_device 申请
失败。

drm_device 分配成功以后还需要使用 drm_dev_register 函数向内核注册，
函数原型如下：
    int drm_dev_register(struct drm_device *dev, unsigned long flags)
    函数参数和返回值含义如下：
dev：需要注册到内核的 drm_device。

flags：传递给驱动.load 函数的标志。

返回值：0，成功；负数，失败
1.5.2 drm_driver 结构体
Linux 内核为 DRM 驱动提供一个叫做 drm_driver 的结构体， drm_driver 结构体包含了 DRM
驱动的完整属性和操作集合，因此每一个 DRM 驱动都必须有一个 drm_driver 。 drm_driver 结构 体定义在 include/drm/drm_drv.h 文件里，

 

drm_driver 结构体的成员变量很多，我们重点关注 driver_features 、 fops 和 dumb_create 。
 
driver_features 用来描述驱动特性，枚举类型 drm_driver_feature 定义了可以选择
的驱动特性（如下）：

 

前面我们说了，STM32MP1 的 LTDC 是个 platform 驱动，当设备和驱动匹配成功以后
stm_drm_platform_probe 函数就会执行，函数内容如下：

 

drv_load 函数

 这里我们要引入 drm_panel 结构体，此结构体作用是提供一堆控制回调函数。

比如屏幕参数回调函数，背光控制函数等等。
        ltdc_load函数是负责初始化 ltdc 接口 ( 同时 connector 和 encoder 一起初始化 )， connector 初始化的时候，就会调用 drm_panel 结构体里的获取屏幕 参数函数( 所以我们只需要提供一个屏的驱动就能正常显示了 ) 。通常 encoder 和 connector 是放 在同一个驱动初始化的，目的是为了方便驱动程序设计。
要完成整个 DRM 驱动的正常初始化，前面的 GEM 和 KMS 这些模块 ST 官方
已经提供给我们了，只需提供一个 drm_panel 对象就行了。打开“ include/drm/drm_panel.h ”文 件，找到如下内容所示：、

 

如果需要驱动rgb屏幕，则只需要提供一个drm_panel对象则可以了。如果需要驱动自己的屏幕只需要修改：

①、在根节点下提供一个 LCD 设备树，包含背光的节点和引用 ltdc 节点。
②、在 panel-simple.c 文件里的 platform_of_match 结构体里添加一组设备 ID，此设备 ID 对
应你所使用的屏幕，重点是屏幕参数 panel_desc 结构体。

以上是关于rgb lcd 需要使用到drm框架的分析，正常如果不是原厂都不会需要自己去写驱动，正常来说都是直接修改设备树，驱动lcd屏幕。

如果有什么不对的欢迎大家指正。

距喜喜
关注
  • 11
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
drm-tip：DRM当前的发展和夜间树木
02-10
drm-tip：DRM当前的发展和夜间树木
drm简介
sinat_35521460的博客
01-06 191
drm
DRM广播系统及接收机技术
01-12
目前工作于中波和短波波段的调幅广播质量远远低于人们的收听要求，2004 年制定的数字音频广播DRM 技术标准，是一种在原中短波频带内，仍占用9kHz(或10kHz)带宽，可提供无干扰的接近调频立体声质量的广播技术。DRM广播是继调幅广播、调频广播之后的第三代广播方式，它的出现标志着广播系统正由模拟向数字体制过渡。目前，国内外采用的 DRM 接收机大多基于P的DRM 软件接收机，已经比较成熟，但其应用范围受到一定限制。因此为促进 DRM系统的推广，需要一种成本较低、可靠性高、体积小和携带方便的硬件DRM 接收机。
drm-tools:Widevine 和 Playready 的工具
05-30
drm-tools Widevine 和 PlayReady 的工具
营销数字音乐：Drm可以帮助吗？-研究论文
05-20
我们认为，数字版权管理技术可以满足多种营销目的，这将使新来的艺术家更容易将其产品展示给消费者，并使知名艺术家可以根据消费者的喜好对其产品进行微调。
Linux DRM how-to 例子
01-05
基本上DRM架构全部取代了传统的fb模式， Linux Graphic DRM subsystem 的测试历程，主要是基于libdrm库进行图形的操作，
Linux图形子系统之DRM显示框架
fs3296的博客
03-28 5093
Linux图形子系统之DRM显示框架引言1 概述1.1 connector 引言 与其他子系统一样，linux抽象出了DRM作为其图形子系统。其中包括显示和渲染，本文主要讲解渲染部分。 1 概述 如图所属，drm将显示部分抽象出了framebuffer、plane、crtc、encoder、connector五部分。 在同一时刻，一个framebuffer与一个plane动态绑定； 在同一时刻，通常一个或多个plane与一个crtc静态绑定； 在同一时刻，一个crtc与多个encoder动态绑定； 在同
我所理解的DRM显示框架
weixin_42432281的博客
05-30 3691
什么是DRM： DRM全称是DirectRenderingManager，是linux主流的一种显示框架，支持多图层合成，为用户图层提供统一的API（libdrm），来访问GPU，实现统一管理。它是为了解决多个程序对video card访问协同资源使用而产生的。DRM可以简单的分成三个模块： libdrm：它是一个库，向上层提供通用的 API，是对底层各种 ioctl 的接口进行封装，用来进行图像显示和图像处理。当然用 drm 的 ioctl 或者是用 framebuffer 来操作显示图像也可以。 .
【项目原理】DRM驱动概念、组成、框架、源码分析
kashine的博客
03-23 8210
Linux 中的驱动和驱动是两种不同的图形驱动方式，它们之间有一些区别。DRM驱动：总之，一句话，DRM是Linux目前主流的图形显示框架，相比FB架构，DRM更能适应当前日益更新的显示硬件。
Linux内核4.14版本——drm框架分析(1)——drm简介
yangguoyu8023的博客
03-03 6027
drm框架分析
drm_framwork:迷你网站的迷你框架PHP
04-12
drm_framwork 迷你网站的迷你框架PHP
DRM框架组件支持音视频媒体业务数字版权管理功能的开发
01-10
DRM（Digital Rights Management）框架组件支持音视频媒体业务数字版权管理功能的开发。开发者可以调用系统提供的DRM插件，完成DRM证书管理、DRM许可证管理等功能，支持DRM加密媒体数据的解密，实现DRM节目授权和解密播放。
rockchip_drm框架介绍
04-21
rockchip_drm的框架介绍，里面还有我收集的DRM框架的基础知识以及对rockchip_drm的一系列代码的解释
Linux报错处理：‘abrt-cli status’ timed out
Rita_rr的博客
04-23 630
abrt-cli是ABRT(Automated Bug Reporting Tool)的命令行接口，用于在Linux系统中处理和报告程序崩溃。 如果abrt-cli status命令超时，这可能是由于多种原因，包括但不限于系统资源不足、ABRT服务未正常运行、网络问题或配置错误。
Linux多进程(五) 进程池 C++实现
最新发布
Lyajpunov的博客
04-26 817
进程池是一种并发编程模式，用于管理和重用多个处理任务的进程。它通常用于需要频繁创建和销毁进程的情况，以避免因此产生的开销。减少进程创建销毁的开销：避免频繁创建和销毁进程所带来的系统资源开销。提高系统响应速度：由于进程已经初始化并且一直保持在内存中，可以立即分配执行任务，减少了任务等待时间。控制资源使用：通过限制进程池中的进程数量，可以控制系统资源的使用情况，避免资源过度消耗。
13 Linux实操篇-网络配置
qq_74289024的博客
04-23 1063
子网ip 与网关。
Linux——web服务配置
Xinan_____的博客
04-23 1136
GET：请求获取指定资源的表示形式。使用GET方法，客户端请求服务器发送某个资源。POST：向指定资源提交数据，用于处理表单提交、文件上传等操作。PUT：向指定资源位置上传其最新内容，用于更新资源。DELETE：请求服务器删除指定资源。HEAD：请求获取与实体相对应的头部信息，用于获取资源的元数据。OPTIONS：请求查询服务器支持的HTTP方法。TRACE：请求服务器回显收到的请求消息，用于测试或诊断。200 OK：请求成功。：永久重定向，请求的资源已经被分配了新的。
高通的DRM图形显示框架开发:drm_atomic_helper_check_plane_state和atomic_pre_enable没被调用
06-03
对于高通的DRM图形显示框架开发，函数drm_atomic_helper_check_plane_state和atomic_pre_enable是在驱动中实现的，并且在plane复合操作和显示设备启用之前被调用。如果这两个函数没有被调用，可能是因为它们没有被正确地注册到驱动中，或者是因为它们没有被正确地调用。您可以检查驱动代码中这些函数的实现是否正确，并确保这些函数被正确地调用，以确保正常的图形显示操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值