1 前言
关于framebuffer的移植，这是我第一次接触稍微高端点的驱动。以前都是学习使用spi和i2c驱动，这些驱动的整体框架已经很熟悉了，且网上资料都烂大街了，所以遇到问题基本都能轻松解决。到了这个驱动，就遇到了很多新问题；首先这个框架甚至都是我第一次听说，因此官方高度优化的代码读起来很费力！且不得不吐槽的一点是官方为了兼容性设置了一大堆宏，加上各种变量的重赋值，综合下来代码简直没法往下读。
没办法，只能去网上查找framebuffer框架的资料先学习一下；幸运的是我找到了拱卒大佬的framebuffer的驱动，也是基于ili9488写的；按道理讲用大佬的驱动，只要适配好设备树基本上屏幕也就能顺利点亮了。基于此我就改起了自己的代码。
然后就卡在设备树的第一道难关上了。我结合拱卒大佬的设备树和官方基于st7789v的lcd屏幕的设备树，编写迭代了自己多个版本的设备树；虽说结合驱动完成了屏幕的各项配置工作，但屏幕始终就是点不亮。怀疑各种问题，各种尝试，就是失败。后面实在是没思路了，就想着先用官方st7789v的屏幕把framebuffer驱动点亮屏幕这条路走通，加深理解后再回头点亮自己的屏幕。
结果不试不知道，一试才发现官方示例的设备树也是错误的。后面顺理成章地在官方论坛上提问,官方给出了正确的设备树。从而爬出了第一个深坑。(官方设备树在原有的基础上关闭了一个spi的节点)
接着又踏进第二个深坑，内核申请的framebuffer空间地址怎么都和应用层通信不成功。一开始怀疑是自己得问题，是自己写得fb_mmap函数有问题，但百度各种mmap函数的写法，代码魔改无数次都失败了；于是怀疑是内核版本的问题，专门实现了操作方法结构体ops中的open函数和fb_mmap函数做对比，看到底问题出在哪里，结果发现open函数被成功调用，但fb_mmap函数一样地实现方式，它就没被成功调用。分析我这个fb_mmap函数的实现方式，这是从网上多个教程交叉验证得到地可行方法啊！应该没问题！既然自己的驱动有问题，那就看官方驱动的调用流程，再反向分析自己的代码。
分析官方st7789v的framebuffer驱动，对比差异查找调用失败原因。发现官方使用得ops中从头到尾也没用到mmap函数，但在应用层竟然能获取到地址，这是让我产生了更深的疑问！因为我无论是从百度还是csdn等各种地方查找的资料都显示：想要在应用层调用mmap的函数，那驱动层必须要在操作方法结构体ops中实现自己的mmap函数。而我在最新的驱动文件中并未发现这个函数，且之前自己写的驱动中实现过这个函数，但系统未调用（实现了fb_open函数和fb_mmap函数，但只调用了open函数，怀疑是mmap函数的参数不对，导致没调用）。
基于上面两点提出了最终的问题，这个函数在哪，怎么被调用的？层层分析，最终抽丝剥茧找到/video/fbdev/core/fbmem.c文件，发现了framebuffer子系统框架对于mmap函数的处理调用逻辑，也明白了这个子系统对于操作方法结构体有自己一套默认的实现函数，在用户驱动未实现自己的操作方法结构体时，系统默认调用这个函数。
至此整个驱动的调用流程就全通了，理所应当屏幕也顺利点亮了。
2 spi驱动简单分析
官方的触摸屏项目来源于树莓派的示例，所以他的spi驱动代码已经很成熟简洁了；整体思路也比较清晰明了，稍微用心看看就能看懂。但缺点就是我上个项目提过的，全部引脚都用的sysfs文件系统在应用层调用；这样的方法感觉虽然简单提高了驱动的兼容性，但也增加了应用层代码的复杂程度。
这里简单梳理一下从应用层到驱动的调用流程，通过第3、4两步可以看出引脚的状态控制是通过sysfs文件系统在应用层控制的，而spi传输数据则是通过ioctl方式将数据发送给驱动，由驱动处理数据后将数据通过spi子系统传输给硬件的！
如下图是sysfs文件系统中设备树与应用层的调用流程。
如下是节选的BL引脚的sysfs的初始化设备树写法。
/ {
model = "Luckfox Pico Plus";
compatible = "rockchip,rv1103g-38x38-ipc-v10", "rockchip,rv1103";
/*LCD_BL*/
gpio0pa4:gpio0pa4 {
compatible = "regulator-fixed";
pinctrl-names = "default";
pinctrl-0 = <&gpio0_pa4>;
regulator-name = "gpio0_pa4";
regulator-always-on;
};
}
&pinctrl {
/*LCD_BL*/
gpio0-pa4 {
gpio0_pa4:gpio0-pa4 {
rockchip,pins = <0 RK_PA4 RK_FUNC_GPIO &pcfg_pull_none>;
};
};
}综上所述可以看出官方demo其实核心思路就是调用spi子系统传输数据，其他代码都是围绕这个核心编写的，把握这个思路，整体读下来就很清晰明了了。
3 framebuffer驱动
想要读懂framebuffer驱动的代码主要看两个模块，一个是初始化函数，一个是操作方法结构体。通过prob入口函数可以了解所有变量及函数的注册及初始化流程；通过ops操作方法结构体可以找到所有调用read、write等接口函数与应用层交互的逻辑；二者结合很容易就能找到思路读懂整个驱动。
整体读下来官方的framebuffer驱动，总结其核心函数就是fb_mmap函数；与硬件交互的核心还是spi子系统那套函数；剩余的关键点就是初始化lcd屏幕得那套逻辑了。总得看写法很复杂，但东西还是那些东西。
3.1 framebuffer子系统
3.1.1 fb_mmap函数
通过我上面的吐槽也能看出，关于framebuffer的问题最终都指向了fb_mmap这个函数。
如下是frammebuffer子系统在/video/fbdev/core/fbmem.c文件中对fb_mmap的函数实现。通过这个函数，内核实现了对空间的分配，以及将地址传递给应用层接口的功能。
3.1.1.1 函数逻辑分析
这个函数在代码初始阶段就使用file_fb_info(file)函数获取fb_info的结构体。若在驱动中已经实现了自己的操作方法结构体，则会返回指针，在下面做进一步处理。没有则执行官方自己的逻辑。
按道理我自己在fb_ops的操作方法结构体中也实现了自己的fb_mmap函数，应该会在执行阶段调用我的函数，却没调用成功；最后怀疑是自己实现函数的参数和类型不对，导致在后续执行时发生了分配空间的错误。
static int
fb_mmap(struct file *file, struct vm_area_struct * vma)
{
//获取驱动的操作方法结构体，并赋给info
struct fb_info *info = file_fb_info(file);
int (*fb_mmap_fn)(struct fb_info *info, struct vm_area_struct *vma);
unsigned long mmio_pgoff;
unsigned long start;
u32 len;
//判断，info为空，返回错误
if (!info)
return -ENODEV;
mutex_lock(&info->mm_lock);
//无论驱动中是否实现了fb_mmap，直接赋值，为空也没问题。
fb_mmap_fn = info->fbops->fb_mmap;
//优化选项，若在config文件中配置，则会使用内核的mmap函数。
#if IS_ENABLED(CONFIG_FB_DEFERRED_IO)
if (info->fbdefio)
fb_mmap_fn = fb_deferred_io_mmap;
#endif
//这里对赋值的fb_mmap_fn函数进行判断，若写了自己的mmap函数，则直接进入，否则执行下一步
if (fb_mmap_fn) {
int res;
/*
* The framebuffer needs to be accessed decrypted, be sure
* SME protection is removed ahead of the call
*/
vma->vm_page_prot = pgprot_decrypted(vma->vm_page_prot);
res = fb_mmap_fn(info, vma);
mutex_unlock(&info->mm_lock);
return res;
}
/*
* Ugh. This can be either the frame buffer mapping, or
* if pgoff points past it, the mmio mapping.
*/
//对于没实现自己mmap的函数，则正常执行系统自带的mmap的逻辑
start = info->fix.smem_start;
len = info->fix.smem_len;
mmio_pgoff = PAGE_ALIGN((start & ~PAGE_MASK) + len) >> PAGE_SHIFT;
if (vma->vm_pgoff >= mmio_pgoff) {
if (info->var.accel_flags) {
mutex_unlock(&info->mm_lock);
return -EINVAL;
}
vma->vm_pgoff -= mmio_pgoff;
start = info->fix.mmio_start;
len = info->fix.mmio_len;
}
mutex_unlock(&info->mm_lock);
vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
/*
* The framebuffer needs to be accessed decrypted, be sure
* SME protection is removed
*/
vma->vm_page_prot = pgprot_decrypted(vma->vm_page_prot);
fb_pgprotect(file, vma, start);
return vm_iomap_memory(vma, start, len);
}3.1.1.2 函数功能实现
搞懂内核对mmap函数的处理逻辑后，对函数做进一步分析，了解关键分配内存空间的流程。
3.1.1.2.1 内存权限分配
vma->vm_page_prot是用来描述映射区域的内存页权限。这里通过调用 pgprot_decrypted()函数，确保映射区域不包含SME（Secure Memory Encryption）保护。
SME是一种内存加密技术，旨在通过硬件级的内存加密来保护系统中的敏感数据。某些平台（例如 AMD EPYC 处理器）支持SME。
pgprot_decrypted()函数会移除SME保护，使得内存可以在未加密的情况下访问。这一步确保映射的 Framebuffer内存是可解密访问的。
vma->vm_page_prot = pgprot_decrypted(vma->vm_page_prot);3.1.1.2.2 映射地址空间
这段代码是 Linux 内核中 fb_mmap 函数的一部分，用于处理 framebuffer 显存（framebuffer memory）和 MMIO（内存映射 I/O）区域的内存映射。它决定了用户空间请求 mmap 时，如何将 framebuffer 或设备的 MMIO 映射到用户进程的地址空间。
//1.提取smem_start和smem_len
start = info->fix.smem_start;
len = info->fix.smem_len;
//info->fix.smem_start：这是 framebuffer的显存起始地址，通常表示设备上显存的物理地址。
//info->fix.smem_len：显存的长度（即显存的大小）。
//这些信息来自于fb_info->fix结构体，通常是在初始化framebuffer时由驱动设置的。
//2.计算mmio_pgoff（MMIO 偏移量）
mmio_pgoff = PAGE_ALIGN((start & ~PAGE_MASK) + len) >> PAGE_SHIFT;
//这里的PAGE_ALIGN是用来将起始地址对齐到页面大小（通常是 4KB）。
//start&~PAGE_MASK会移除低位地址中的页面偏移量（即只保留页面对齐的部分）。
//将显存地址start和长度len对齐后，计算对应的页面偏移量，并通过>>PAGE_SHIFT将字节偏移量转化为页偏移量。
//mmio_pgoff表示MMIO区域的页偏移量。MMIO 是内存映射I/O，用于访问硬件寄存器或其他非标准内存区域。
//3.判断是否为 MMIO 区域
if (vma->vm_pgoff >= mmio_pgoff) {
//vma->vm_pgoff：这个是用户请求 mmap 时传递的页面偏移量，表示用户想映射的内存区域的起始地址。
//如果用户请求的页面偏移量大于等于 mmio_pgoff，意味着用户想要访问的内存超出了 framebuffer 显存区域，可能在请求 MMIO 区域。
//4.处理 MMIO 区域的映射
if (info->var.accel_flags) {
mutex_unlock(&info->mm_lock);
return -EINVAL;
}
//如果设备有硬件加速功能（info->var.accel_flags 表示加速标志位），则不允许映射 MMIO 区域，返回错误 -EINVAL。
vma->vm_pgoff -= mmio_pgoff;
start = info->fix.mmio_start;
len = info->fix.mmio_len;
//如果没有硬件加速，则处理 MMIO 区域的映射。
//vma->vm_pgoff -= mmio_pgoff：调整偏移量，减去显存区域的页偏移量，以便接下来映射 MMIO 区域。
//将 start 设置为 info->fix.mmio_start（MMIO 的起始地址），将 len 设置为 info->fix.mmio_len（MMIO 的长度），从而准备映射 MMIO 内存。
//5.解锁互斥锁
mutex_unlock(&info->mm_lock);
//之前在函数开始时锁定了 info->mm_lock，现在需要解锁。该锁确保对 info 结构的访问是线程安全的。
//6.设置内存页权限
vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
vma->vm_page_prot = pgprot_decrypted(vma->vm_page_prot);
//vm_get_page_prot(vma->vm_flags)：根据 vma 的标志位，获取合适的内存页面权限。
//pgprot_decrypted(vma->vm_page_prot)：确保 SME（Secure Memory Encryption）保护被移除，以允许未加密访问。这是为了适配某些硬件的加密机制，确保内存可以直接访问。
//7.保护 framebuffer 映射
fb_pgprotect(file, vma, start);
//该函数确保映射的 framebuffer 或 MMIO 区域具备适当的保护措施（如只读或可读写权限）。fb_pgprotect 是一个辅助函数，用于调整页表的权限。
//8.将内存映射到用户空间
return vm_iomap_memory(vma, start, len);
//vm_iomap_memory：将物理内存（start 到 start+len）映射到用户进程的地址空间。这是一个通用的内核函数，处理将物理内存页映射到虚拟内存。3.1.2 驱动接口注册
当framebuffer驱动被加载时，驱动会调用 register_framebuffer()函数来注册framebuffer设备。在这个过程中，/dev/fb0 设备节点也会自动创建。
int register_framebuffer(struct fb_info *fb_info)3.1.3 应用层接口示例
在驱动成功注册fb0接口后，应用层即可利用此接口获取文件描述符，进一步利用mmap在应用层的接口获取分配的内存空间的地址，传输图像数据给内核。如下是应用层测试用例：
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <linux/fb.h>
#include <sys/ioctl.h>
#include <stdint.h>
#include <string.h>
// 定义颜色
#define RED 0x00FF0000
#define GREEN 0x0000FF00
#define BLUE 0x000000FF
#define WHITE 0x00FFFFFF
#define BLACK 0x00000000
// framebuffer 结构
struct framebuffer_info {
uint32_t width; // 屏幕宽度
uint32_t height; // 屏幕高度
uint32_t bpp; // 每像素位数
size_t screensize; // 映射内存的大小
uint32_t *fbp; // framebuffer指针
};
struct framebuffer_info get_framebuffer_info(int fb_fd) {
struct framebuffer_info fb_info;
struct fb_var_screeninfo vinfo;
struct fb_fix_screeninfo finfo;
// 获取固定的屏幕信息
ioctl(fb_fd, FBIOGET_FSCREENINFO, &finfo);
// 获取可变的屏幕信息
ioctl(fb_fd, FBIOGET_VSCREENINFO, &vinfo);
fb_info.width = vinfo.xres;
fb_info.height = vinfo.yres;
fb_info.bpp = vinfo.bits_per_pixel;
fb_info.screensize = finfo.smem_len;
return fb_info;
}
void draw_color(struct framebuffer_info *fb_info, uint32_t color) {
size_t pixels = fb_info->width * fb_info->height;
for (size_t i = 0; i < pixels; ++i) {
fb_info->fbp[i] = color;
}
}
int main() {
int fb_fd = open("/dev/fb0", O_RDWR);
if (fb_fd == -1) {
perror("Error: cannot open framebuffer device");
exit(1);
}
struct framebuffer_info fb_info = get_framebuffer_info(fb_fd);
// 使用 mmap 映射 framebuffer 到内存
fb_info.fbp = (uint32_t*)mmap(0, fb_info.screensize, PROT_READ | PROT_WRITE, MAP_SHARED, fb_fd, 0);
if ((intptr_t)fb_info.fbp == -1) {
perror("Error: failed to mmap");
close(fb_fd);
exit(1);
}
// 显示红色
draw_color(&fb_info, RED);
sleep(2); // 显示 2 秒
// 显示绿色
draw_color(&fb_info, GREEN);
sleep(2); // 显示 2 秒
// 显示蓝色
draw_color(&fb_info, BLUE);
sleep(2); // 显示 2 秒
// 清除屏幕，显示黑色
draw_color(&fb_info, BLACK);
sleep(2); // 显示 2 秒
// 取消映射并关闭 framebuffer 设备
munmap(fb_info.fbp, fb_info.screensize);
close(fb_fd);
return 0;
}3.2 framebuffer驱动的颜色显示模块
应用层到驱动的路通了以后，接着分析驱动到硬件的路。
传输数据前首要的工作就是对应用层的数据进行处理，而这段处理程序恰恰也是整个驱动中最琐碎的代码。不难但混乱，读代码时要频繁的跳转寻找其调用逻辑，来理解驱动作者编写的思路。
3.2.1 驱动中的结构体
理解代码的第一步，分析驱动的数据结构体。如下是驱动自身编写的结构体。
struct fbtft_par {
struct spi_device *spi;//spi指针
struct platform_device *pdev;
struct fb_info *info;//内核的fb的信息结构体
struct fbtft_platform_data *pdata;
u32 pseudo_palette[16];
struct {
void *buf;
size_t len;
} txbuf;
u8 *buf;
struct fbtft_ops fbtftops;//操作方法结构体指针
struct {
struct mutex lock;
u32 *curves;
int num_values;
int num_curves;
} gamma;
bool bgr;//红蓝反置标志位
void *extra;
bool polarity;
};如下是内核frammebuffer子系统的结构体，存储着子系统的各类信息。
struct fb_info {
int node; // framebuffer 的编号，例如 /dev/fb0 则 node 为 0
int flags; // 标志位，控制设备行为
struct mutex lock; // 保护 fb_info 的锁
struct mutex mm_lock; // 映射操作 (mmap) 的锁
struct fb_var_screeninfo var; // 可变屏幕信息，如分辨率、色深等
struct fb_fix_screeninfo fix; // 固定屏幕信息，如显存地址等
struct fb_monspecs monspecs; // 显示器的规格信息
struct fb_pixmap pixmap; // 一些图片缓冲相关信息
struct fb_ops *fbops; // 指向 framebuffer 操作函数的指针（包括 mmap、read、write 等）
struct device *device; // 指向该 framebuffer 设备的指针
struct fb_deferred_io *fbdefio; // 延迟 IO 相关结构体（如果支持的话）
void *pseudo_palette; // 用于伪调色板的存储
void *par; // 驱动程序的私有数据
unsigned char *screen_base; // 显存的起始地址
unsigned long screen_size; // 显存的大小
// ... 其他成员
};3.2.2 驱动的初始化
驱动的prob入口是匹配成功后进入的主函数，因此一系列初始化操作均在这个函数中进行。如下是截取的关键函数部分：
int fbtft_probe_common(struct fbtft_display *display,
struct spi_device *sdev,
struct platform_device *pdev)
{
struct device *dev;
struct fb_info *info;
struct fbtft_par *par;
struct fbtft_platform_data *pdata;
info = fbtft_framebuffer_alloc(display, dev, pdata); //创建一个新的帧缓冲区信息结构，分配空间等操作由此进入初始化info的结构体，初始化各项参数
struct fb_info *fbtft_framebuffer_alloc(struct fbtft_display *display,
struct device *dev,
struct fbtft_platform_data *pdata)
{
struct fb_info *info;
struct fbtft_par *par;
struct fb_ops *fbops = NULL;//分配帧缓冲设备
info = framebuffer_alloc(sizeof(struct fbtft_par), dev);
fbops->owner = dev->driver->owner;
fbops->fb_read = fb_sys_read;
fbops->fb_write = fbtft_fb_write;
fbops->fb_fillrect = fbtft_fb_fillrect;
fbops->fb_copyarea = fbtft_fb_copyarea;
fbops->fb_imageblit = fbtft_fb_imageblit;
fbops->fb_setcolreg = fbtft_fb_setcolreg;
fbops->fb_blank = fbtft_fb_blank;
fbdefio->delay = HZ / fps;
fbdefio->deferred_io = fbtft_deferred_io;
fb_deferred_io_init(info);
//初始化结构体的固定参数
snprintf(info->fix.id, sizeof(info->fix.id), "%s", dev->driver->name);
info->fix.type = FB_TYPE_PACKED_PIXELS;
info->fix.visual = FB_VISUAL_TRUECOLOR;
info->fix.xpanstep = 0;
//...大部分初始化参数省略3.2.3 配置颜色相关结构体与函数
配置颜色涉及到了核心的fbtft_framebuffer_alloc函数，通过对此函数调用流程的分析，了解系统对颜色数据的处理操作。
3.2.3.1 初始化结构体函数指针
//在fbtft_framebuffer_alloc函数中初始化函数指针
fbops->fb_setcolreg = fbtft_fb_setcolreg;
//配置颜色的数据类型
/* RGB565 *///红蓝反了
info->var.red.offset = 11;
info->var.red.length = 5;
info->var.green.offset = 5;
info->var.green.length = 6;
info->var.blue.offset = 0;
info->var.blue.length = 5;
info->var.transp.offset = 0;
info->var.transp.length = 0;
info->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB;3.2.3.2 设置颜色寄存器(调色板)的函数
到这其实基本就可以停止分析了，因为分析到这我发现驱动压根就没使用这个显示颜色的方式。从下面代码可以看出，pal[regno]在这赋值后，压根就没有函数调用这个接口。驱动是直接使用的"rgb565"16位的颜色数据。
//设置颜色寄存器的函数
static int fbtft_fb_setcolreg(unsigned int regno, unsigned int red,
unsigned int green, unsigned int blue,
unsigned int transp, struct fb_info *info)
{
unsigned int val;
int ret = 1;
dev_dbg(info->dev,
"%s(regno=%u, red=0x%X, green=0x%X, blue=0x%X, trans=0x%X)\n",
__func__, regno, red, green, blue, transp);
switch (info->fix.visual) {
case FB_VISUAL_TRUECOLOR:
//配置的基础色一共16个
if (regno < 16) {
u32 *pal = info->pseudo_palette;
val = chan_to_field(red, &info->var.red);
val |= chan_to_field(green, &info->var.green);
val |= chan_to_field(blue, &info->var.blue);
//根据值确定最后的颜色
pal[regno] = val;
ret = 0;
}
break;
}
return ret;
}将通道值转换成一个帧缓冲的16位字段值
/* from pxafb.c */
//将通道值转换成一个帧缓冲的16位字段值
static unsigned int chan_to_field(unsigned int chan, struct fb_bitfield *bf)
{
chan &= 0xffff;
chan >>= 16 - bf->length;
return chan << bf->offset;
}3.2.3.3 8位真彩的显示逻辑
假设驱动使用此方式显示颜色，继续往下分析。因此需要先了解8位真彩以及调色板的概念。
调色板的概念：假如LCD的数据位为16位，那么framebuffer应该每个像素占据16bit，但是为了节省空间，使用8bit表示一个像素，这时候需要引入调色板才能正确传输16位的数据给LCD（正确传输每个像素的数据）。调色板其实就是一片内存，这里面每一格存放16bit的数据。当LCD控制器从framebuffer中取出8bit的数据后，不是直接传给LCD，而是用这个8bit作为索引，从调色板中取出16bit的数据，然后发给LCD。所以，在使用8BPP（每个像素点的位数）格式时，framebuffer中存放的是伪彩色。16BPP或者24BPP格式时，framebuffer中存放的才是真彩色。所以在使用8BPP格式时，首先要设置调色板。如下图是调用逻辑：
综上所述我们了解了整个8位真彩显示的调用流程，驱动代码里缺失的部分就是从应用层获取8位的颜色编码后，通过编码调用调色板的逻辑，因为没用过就没写这个逻辑，大概了解就行了。
3.2.3.4 应用层调用调色板示例
如下代码是简单的调用ioctl接口实现8位真彩显示颜色的示例；如果想用mmap的接口，只需把颜色数据处理部分放到驱动中，应用层与驱动层配置好传输协议可以了。
#include <linux/fb.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
int set_color(int fb_fd, unsigned int regno, unsigned int red, unsigned int green, unsigned int blue) {
struct fb_cmap cmap;
cmap.start = regno; // 设置颜色寄存器号
cmap.len = 1; // 只设置一个颜色
cmap.red = &red; // 红色值
cmap.green = &green; // 绿色值
cmap.blue = &blue; // 蓝色值
cmap.transp = NULL; // 不透明度
return ioctl(fb_fd, FBIOPUTCMAP, &cmap);
}
int main() {
int fb_fd = open("/dev/fb0", O_RDWR);
if (fb_fd < 0) {
return -1;
}
// 设置寄存器 0 对应的颜色为红色
set_color(fb_fd, 0, 0xFFFF, 0x0000, 0x0000);
close(fb_fd);
return 0;
}3.2.3.5 实际颜色显示方式
而在本驱动中并未使用上文显示颜色的逻辑；因为使用的是16位rgb565颜色数据，frammebuffer直接接收颜色数据发送给屏幕即可，不需要像这种8位真彩一样进行数据处理。实际的显示颜色的方式看上文mmap函数的整体调用流程。
3.3 framebuffer中的spi子系统
驱动不论怎么写，但凡涉及到spi接口的数据传输，肯定会使用spi子系统。唯一的区别在于开发人员会因势利导对子系统代码的调用做更合适本驱动的优化罢了！
3.3.1 初始化驱动自带的结构体
通过prob函数初始化fbtft_framebuffer_alloc函数中的par驱动私有结构体。
//初始化par结构体的各项参数，如调试标志，缓冲区指针，旋转角度，gamma曲线
par = info->par;
par->info = info;
par->pdata = pdata;
par->debug = display->debug;
par->buf = buf;
spin_lock_init(&par->dirty_lock);
//par->bgr = pdata->bgr;
par->bgr = 1;//红蓝反置参数
par->fbtftops.write = fbtft_write_spi;//spi子系统的写函数
par->fbtftops.write_vmem = fbtft_write_vmem16_bus8;//spi子系统写函数的调用函数
//...大部分初始化参数省略3.3.2 实际初始化逻辑
分析fbtft_write_vmem16_bus8函数；在上述结构体中虽然赋值了，但在prob函数中又重新进行了赋值判断，所以上面的赋值无效。真正的赋值逻辑如下所示，需要判断总线宽度的值，来确定传输函数到底是哪个？
if (display->buswidth == 8)
par->fbtftops.write_vmem = fbtft_write_vmem16_bus8;
else if (display->buswidth == 9)
par->fbtftops.write_vmem = fbtft_write_vmem16_bus9;
else if (display->buswidth == 16)
par->fbtftops.write_vmem = fbtft_write_vmem16_bus16;3.3.3 buildwith的赋值
//从设备的属性中读取信息，填充到fbtft_platform_data结构体中
static struct fbtft_platform_data *fbtft_properties_read(struct device *dev)
{
struct fbtft_platform_data *pdata;
pdata->display.buswidth = fbtft_property_value(dev, "buswidth");
pdata->bgr = device_property_read_bool(dev, "bgr");3.3.4 设备树的配置
配置设备树中的buswidth属性值。
ili9488@0{
compatible = "ilitek,ili9488";
buswidth = <8>;
bgr = <1>;
};3.3.5 调用fbtft_write_vmem16_bus8的流程
在确定这个是写函数后，那就要确定其调用流程，逐层分析调用代码逻辑。具体调用流程如下：
1.将写函数集成进刷新屏幕的函数中，将多个函数抽象为刷新屏幕功能。
//更新显示屏的内容，根据起始行和结束行的，将对应的显存内容写入到显示屏
static void fbtft_update_display(struct fbtft_par *par, unsigned int start_line,
unsigned int end_line)
{
ret = par->fbtftops.write_vmem(par, offset, len);2.为结构体中的函数指针赋值。
par->fbtftops.update_display = fbtft_update_display;3.注册阶段调用更新屏幕函数
注册阶段需要调用写函数传输初始化命令等操作。在register中调用更新屏幕的逻辑间接调用写函数。
int fbtft_register_framebuffer(struct fb_info *fb_info)
{
par->fbtftops.update_display(par, 0, par->info->var.yres - 1);最后由prob函数中调用注册函数，向写函数中传输数据。
int fbtft_probe_common(struct fbtft_display *display,
struct spi_device *sdev,
struct platform_device *pdev)
{
ret = fbtft_register_framebuffer(info);5.正常刷新屏幕
除了注册阶段要写数据，刷新屏幕也要写数据。此部分驱动地思路是使用定时器固定时间步长调用刷新函数传输数据。具体地逻辑如下：
//延时io函数
static void fbtft_deferred_io(struct fb_info *info, struct list_head *pagelist)
{
par->fbtftops.update_display(info->par,
dirty_lines_start, dirty_lines_end);将驱动的延时I/O函数填充到函数指针中；并初始化定时器函数。
fbdefio->deferred_io = fbtft_deferred_io;
fb_deferred_io_init(info);正常追函数到这里又断掉了，分析发现fb_deferred_io_init是frammebuffer子系统自带的延时I/O机制函数。内部使用定时器实现了定时调用写函数的逻辑，将缓冲区内的数据传输到lcd屏幕上。函数的实现在drivers/video/fbdev/core/fb_defio.c文件里。
3.3.6 处理数据的逻辑
分析到此处可以看出驱动调用的函数是fbtft_write_vmem16_bus8。整体思路就是将数据存放到vmem16的数组中，然后利用系统的转换字节序的接口进行数据处理，然后发给下面的spi子系统。
/* 16 bit pixel over 8-bit databus */
int fbtft_write_vmem16_bus8(struct fbtft_par *par, size_t offset, size_t len)
{
u16 *vmem16;
__be16 *txbuf16 = par->txbuf.buf;
size_t remain;
size_t to_copy;
size_t tx_array_size;
int i;
int ret = 0;
size_t startbyte_size = 0;
fbtft_par_dbg(DEBUG_WRITE_VMEM, par, "%s(offset=%zu, len=%zu)\n",
__func__, offset, len);
remain = len / 2;
vmem16 = (u16 *)(par->info->screen_buffer + offset);
gpiod_set_value(par->gpio.dc, 1);
/* non buffered write */
if (!par->txbuf.buf)
return par->fbtftops.write(par, vmem16, len);
/* buffered write */
tx_array_size = par->txbuf.len / 2;
if (par->startbyte) {
txbuf16 = par->txbuf.buf + 1;
tx_array_size -= 2;
*(u8 *)(par->txbuf.buf) = par->startbyte | 0x2;
startbyte_size = 1;
}
while (remain) {
to_copy = min(tx_array_size, remain);
dev_dbg(par->info->device, "to_copy=%zu, remain=%zu\n",
to_copy, remain - to_copy);
for (i = 0; i < to_copy; i++)
{
txbuf16[i] = cpu_to_be16(vmem16[i]);
// printk("转换字节序aaaaaaaaa\n");
}
vmem16 = vmem16 + to_copy;
ret = par->fbtftops.write(par, par->txbuf.buf,
startbyte_size + to_copy * 2);
if (ret < 0)
return ret;
remain -= to_copy;
}
return ret;
}3.3.7 spi子系统传输数据
调用spi子系统par->fbtftops.write。
int fbtft_write_spi(struct fbtft_par *par, void *buf, size_t len)
{
struct spi_transfer t = {
.tx_buf = buf,
.len = len,
};
struct spi_message m;
fbtft_par_dbg_hex(DEBUG_WRITE, par, par->info->device, u8, buf, len,
"%s(len=%zu): ", __func__, len);
if (!par->spi) {
dev_err(par->info->device,
"%s: par->spi is unexpectedly NULL\n", __func__);
return -1;
}
spi_message_init(&m);
spi_message_add_tail(&t, &m);
return spi_sync(par->spi, &m);
}驱动中spi子系统的调用流程完成。
3.4 小结
完成这个驱动后，总结发现framebuffer驱动对比原有spi驱动的优点和核心就是使用了fb_mmap函数。它是framebuffer设备相关的一个内存映射函数。它的主要作用是将framebuffer或MMIOMemory-Mapped I/O）区域映射到用户空间，使用户可以通过内存访问设备数据。最终效果就是提高了应用层和内核数据的传输效率。
至此驱动的主线逻辑就已经捋清楚了，其他部分代码逻辑简单清晰，没啥讲解地必要。另外有一部分初始化地逻辑在硬件篇已讲过，驱动篇就不再赘述了！
如下是我最终适配完成的驱动：
// SPDX-License-Identifier: GPL-2.0+
/*
* FB driver for the ST7789V LCD Controller
*
* Copyright (C) 2015 Dennis Menschel
*/
#include < linux/bitops.h >
#include < linux/delay.h >
#include < linux/init.h >
#include < linux/kernel.h >
#include < linux/module.h >
#include < video/mipi_display.h >
#include < linux/export.h >
#include < linux/errno.h >
#include < linux/gpio/consumer.h >
#include < linux/spi/spi.h >
#include < linux/string.h >
#include < linux/mm.h >
#include < linux/vmalloc.h >
#include < linux/slab.h >
#include < linux/fb.h >
#include < linux/uaccess.h >
#include < linux/backlight.h >
#include < linux/platform_device.h >
#include < linux/property.h >
#include < linux/spinlock.h >
#include < linux/gpio.h >
#include < linux/of_gpio.h >
#define DRVNAME "ili9488"
#define FBTFT_GPIO_NAME_SIZE 32
struct fbtft_par; //预先声明，否则不识别结构体
struct fbtft_gpio;
/*********************************************************驱动所需结构体*************************************************************************************/
/**
* struct fbtft_ops - FBTFT operations structure fbtft操作结构
* @write: Writes to interface bus 写到接口总线
* @read: Reads from interface bus 从接口总线读取
* @write_vmem: Writes video memory to display 写显存到显示器
* @write_reg: Writes to controller register 写入控制器寄存器
* @set_addr_win: Set the GRAM update window 设置GRAM更新窗口
* @reset: Reset the LCD controller 重置lcd控制器
* @mkdirty: Marks display lines for update 标记显示行更新
* @update_display: Updates the display 更新显示
* @init_display: Initializes the display 初始化显示
* @blank: Blank the display (optional) 清空显示（可选）
* @request_gpios_match: Do pinname to gpio matching 做pinname到gpio匹配
* @request_gpios: Request gpios from the kernel 从内核请求gpios
* @free_gpios: Free previously requested gpios 释放以前请求得gpio
* @verify_gpios: Verify that necessary gpios is present (optional) 验证是否存在必要得gpios（可选）
* @register_backlight: Used to register backlight device (optional) 用于注册背光设备（可选）
* @unregister_backlight: Unregister backlight device (optional) 注销背光设备（可选）
* @set_var: Configure LCD with values from variables like @rotate and @bgr 用rotate和bgr等变量值设置lcd
* (optional)
* @set_gamma: Set Gamma curve (optional) 设置gamma曲线（可选）
*
* Most of these operations have default functions assigned to them in 这些操作中得大多数都有为其分配得默认函数
* fbtft_framebuffer_alloc()
*/
struct fbtft_ops {
int (*write)(struct fbtft_par *par, void *buf, size_t len);
int (*read)(struct fbtft_par *par, void *buf, size_t len);
int (*write_vmem)(struct fbtft_par *par, size_t offset, size_t len);
void (*write_register)(struct fbtft_par *par, int len, ...);
void (*set_addr_win)(struct fbtft_par *par,
int xs, int ys, int xe, int ye);
void (*reset)(struct fbtft_par *par);
void (*mkdirty)(struct fb_info *info, int from, int to);
void (*update_display)(struct fbtft_par *par,
unsigned int start_line, unsigned int end_line);
int (*init_display)(struct fbtft_par *par);
int (*blank)(struct fbtft_par *par, bool on);
unsigned long (*request_gpios_match)(struct fbtft_par *par,
const struct fbtft_gpio *gpio);
int (*request_gpios)(struct fbtft_par *par);
int (*verify_gpios)(struct fbtft_par *par);
void (*register_backlight)(struct fbtft_par *par);
void (*unregister_backlight)(struct fbtft_par *par);
int (*set_var)(struct fbtft_par *par);
int (*set_gamma)(struct fbtft_par *par, u32 *curves);
};
/**
* struct fbtft_display - Describes the display properties 描述显示属性
* @width: Width of display in pixels 显示宽度（以像素为单位）
* @height: Height of display in pixels 显示高度（以像素为单位）
* @regwidth: LCD Controller Register width in bits lcd控制寄存器宽度
* @buswidth: Display interface bus width in bits 显示接口总线宽度
* @backlight: Backlight type. 背光类型
* @fbtftops: FBTFT operations provided by driver or device (platform_data) 驱动程序或设备提供的FBTFT操作（platform_data）
* @bpp: Bits per pixel 比特每像素
* @fps: Frames per second 每秒帧数
* @txbuflen: Size of transmit buffer 传输缓冲区的大小
* @init_sequence: Pointer to LCD initialization array 指向lcd初始化数组的指针
* @gamma: String representation of Gamma curve(s) gamma曲线的字符串表示形式
* @gamma_num: Number of Gamma curves gamma曲线的个数
* @gamma_len: Number of values per Gamma curve 每个伽马曲线的值的数量
* @debug: Initial debug value 初始调试值
*
* This structure is not stored by FBTFT except for init_sequence. 这个结构体不被fbtft储存
*/
struct fbtft_display {
unsigned int width;
unsigned int height;
unsigned int regwidth;
unsigned int buswidth;
unsigned int backlight;
struct fbtft_ops fbtftops;
unsigned int bpp;
unsigned int fps;
int txbuflen;
const s16 *init_sequence;
char *gamma;
int gamma_num;
int gamma_len;
unsigned long debug;
};
/**
* struct fbtft_platform_data - 向驱动程序传递特定的显示数据
* @display: 显示属性
* @gpios: 指向gpio映射的pinname数组的指针
* @rotate: 显示旋转角度
* @bgr: lcd控制的bgr位
* @fps: 每秒帧率数（这将消失，在@fbtft_display中使用@fps）
* @txbuflen: 传输缓冲区的大小
* @startbyte: 当被设置时，启用在传输中使用Startbyte
* @gamma:gamma曲线的字符串表述形式
* @extra:传递额外信息的方法
*/
struct fbtft_platform_data {
struct fbtft_display display;
unsigned int rotate;
bool bgr;
unsigned int fps;
int txbuflen;
u8 startbyte;
char *gamma;
void *extra;
};
/**
* struct fbtft_par - Main FBTFT data structure 主fbtft数据结构
*
* This structure holds all relevant data to operate the display 该结构保存了操作显示器所需的所有相关数据
*
* See sourcefile for documentation since nested structs is not kernel-doc不支持嵌套结构，参与源文件获取文档
* supported by kernel-doc.
*
*/
/* @spi: Set if it is a SPI device 当是spi设备时设置
* @pdev: Set if it is a platform device 当是平台设备是的设置
* @info: Pointer to framebuffer fb_info structure fb_info结构的指针
* @pdata: Pointer to platform data 指向平台数据的指针
* @ssbuf: Not used 没有使用
* @pseudo_palette: Used by fb_set_colreg() 由fb_set_colreg()使用
* @txbuf.buf: Transmit buffer 发送缓冲区
* @txbuf.len: Transmit buffer length 发送缓冲区长度
* @buf: Small buffer used when writing init data over SPI 在spi上写init数据时使用的小缓冲区
* @startbyte: Used by some controllers when in SPI mode. 在spi模式下由一些控制器使用
* Format: 6 bit Device id + RS bit + RW bit 数据格式
* @fbtftops: FBTFT operations provided by driver or device (platform_data) 驱动程序或设备提供的fbtft操作（plaplatform_data）
* @dirty_lock: Protects dirty_lines_start and dirty_lines_end 保护irty_lines_start 和 dirty_lines_end的锁
* @dirty_lines_start: Where to begin updating display 从哪里开始更新显示
* @dirty_lines_end: Where to end updating display 在哪里结束更新显示
* @gpio.reset: GPIO used to reset display reset用于复位显示的gpio
* @gpio.dc: Data/Command signal, also known as RS dc数据/命令信号也称为rs
* @gpio.rd: Read latching signal 读取锁存信号
* @gpio.wr: Write latching signal 写锁存信号
* @gpio.latch: Bus latch signal, eg. 16->8 bit bus latch 锁存：总线锁存信号 如16->8位总线锁存
* @gpio.cs: LCD Chip Select with parallel interface bus lcd芯片选择带并行接口总线
* @gpio.db[16]: Parallel databus 并行数据总线
* @gpio.led[16]: Led control signals led控制信号
* @gpio.aux[16]: Auxiliary signals, not used by core 辅助信号，不被core使用
* @init_sequence: Pointer to LCD initialization array 指向lcd初始化数组的指针
* @gamma.lock: Mutex for Gamma curve locking gamma曲线锁的互斥锁
* @gamma.curves: Pointer to Gamma curve array 指向gamma曲线数组的指针
* @gamma.num_values: Number of values per Gamma curve meiggamma曲线的值的数量
* @gamma.num_curves: Number of Gamma curves gamma曲线的个数
* @debug: Pointer to debug value 指向调试值得指针
* @current_debug:
* @first_update_done: Used to only time the first display update 用于计算第一次显示更新得时间
* @update_time: Used to calculate 'fps' in debug output 用于计算调试输出中得“fps”
* @bgr: BGR mode/\n bgr模式
* @extra: Extra info needed by driver 驱动程序需要得额外信息
*/
struct fbtft_par {
struct spi_device *spi;
struct platform_device *pdev;
struct fb_info *info;
struct fbtft_platform_data *pdata;
u16 *ssbuf;
u32 pseudo_palette[16];
struct {
void *buf;
size_t len;
} txbuf;
u8 *buf;
u8 startbyte;
struct fbtft_ops fbtftops;
spinlock_t dirty_lock;
unsigned int dirty_lines_start;
unsigned int dirty_lines_end;
struct {
struct gpio_desc *reset;
struct gpio_desc *dc;
struct gpio_desc *rd;
struct gpio_desc *wr;
struct gpio_desc *latch;
struct gpio_desc *cs;
struct gpio_desc *db[16];
struct gpio_desc *led[16];
struct gpio_desc *aux[16];
} gpio;
const s16 *init_sequence;
struct {
struct mutex lock;
u32 *curves;
int num_values;
int num_curves;
} gamma;
unsigned long debug;
bool first_update_done;
ktime_t update_time;
bool bgr;
void *extra;
bool polarity;
};
/**
* struct fbtft_gpio - Structure that holds one pinname to gpio mapping 保存一个到gpio映射得pin名得结构
* @name: pinname (reset, dc, etc.)
* @gpio: GPIO number
*
*/
struct fbtft_gpio {
char name[FBTFT_GPIO_NAME_SIZE];
struct gpio_desc *gpio;
};
/***********************************************************驱动所需结构体结束********************************************************************/
/****************************************************fbtft-bus.c文件的函数宏开始***********************************************************/
#define define_fbtft_write_reg(func, buffer_type, data_type, modifier) \
void func(struct fbtft_par *par, int len, ...) \
{ \
va_list args; \
int i, ret; \
int offset = 0; \
buffer_type *buf = (buffer_type *)par->buf; \
\
if (unlikely(par->debug & DEBUG_WRITE_REGISTER)) { \
va_start(args, len); \
for (i = 0; i < len; i++) { \
buf[i] = modifier((data_type)va_arg(args, \
unsigned int)); \
} \
va_end(args); \
fbtft_par_dbg_hex(DEBUG_WRITE_REGISTER, par, \
par->info->device, buffer_type, buf, len, \
"%s: ", __func__); \
} \
\
va_start(args, len); \
\
if (par->startbyte) { \
*(u8 *)par->buf = par->startbyte; \
buf = (buffer_type *)(par->buf + 1); \
offset = 1; \
} \
\
*buf = modifier((data_type)va_arg(args, unsigned int)); \
ret = fbtft_write_buf_dc(par, par->buf, sizeof(data_type) + offset, \
0); \
if (ret < 0) \
goto out; \
len--; \
\
if (par->startbyte) \
*(u8 *)par->buf = par->startbyte | 0x2; \
\
if (len) { \
i = len; \
while (i--) \
*buf++ = modifier((data_type)va_arg(args, \
unsigned int)); \
fbtft_write_buf_dc(par, par->buf, \
len * (sizeof(data_type) + offset), 1); \
} \
out: \
va_end(args); \
}
#define NUMARGS(...) (sizeof((int[]){__VA_ARGS__}) / sizeof(int))
#define write_reg(par, ...) \
((par)->fbtftops.write_register(par, NUMARGS(__VA_ARGS__), __VA_ARGS__))
#define fbtft_init_dbg(dev, format, arg...) \
do { \
if (unlikely((dev)->platform_data && \
(((struct fbtft_platform_data *)(dev)->platform_data)->display.debug & DEBUG_DRIVER_INIT_FUNCTIONS))) \
dev_info(dev, format, ##arg); \
} while (0)
#define fbtft_par_dbg(level, par, format, arg...) \
do { \
if (unlikely((par)->debug & (level))) \
dev_info((par)->info->device, format, ##arg); \
} while (0)
#define fbtft_par_dbg_hex(level, par, dev, type, buf, num, format, arg...) \
do { \
if (unlikely((par)->debug & (level))) \
fbtft_dbg_hex(dev, sizeof(type), buf,\
(num) * sizeof(type), format, ##arg); \
} while (0)
/************************************************fbtft-bus.c文件的函数宏结束***************************************************************/
/*****************************************************平台总线判断函数实现*********************************************************************/
#define FBTFT_REGISTER_DRIVER(_name, _compatible, _display) \
\
static int fbtft_driver_probe_spi(struct spi_device *spi) \
{ \
return fbtft_probe_common(_display, spi, NULL); \
} \
\
static int fbtft_driver_remove_spi(struct spi_device *spi) \
{ \
struct fb_info *info = spi_get_drvdata(spi); \
\
return fbtft_remove_common(&spi->dev, info); \
} \
\
static int fbtft_driver_probe_pdev(struct platform_device *pdev) \
{ \
return fbtft_probe_common(_display, NULL, pdev); \
} \
\
static int fbtft_driver_remove_pdev(struct platform_device *pdev) \
{ \
struct fb_info *info = platform_get_drvdata(pdev); \
\
return fbtft_remove_common(&pdev->dev, info); \
} \
\
static const struct of_device_id dt_ids[] = { \
{ .compatible = _compatible }, \
{}, \
}; \
\
MODULE_DEVICE_TABLE(of, dt_ids); \
\
\
static struct spi_driver fbtft_driver_spi_driver = { \
.driver = { \
.name = _name, \
.of_match_table = dt_ids, \
}, \
.probe = fbtft_driver_probe_spi, \
.remove = fbtft_driver_remove_spi, \
}; \
\
static struct platform_driver fbtft_driver_platform_driver = { \
.driver = { \
.name = _name, \
.owner = THIS_MODULE, \
.of_match_table = dt_ids, \
}, \
.probe = fbtft_driver_probe_pdev, \
.remove = fbtft_driver_remove_pdev, \
}; \
\
static int __init fbtft_driver_module_init(void) \
{ \
int ret; \
\
ret = spi_register_driver(&fbtft_driver_spi_driver); \
if (ret < 0) \
return ret; \
ret = platform_driver_register(&fbtft_driver_platform_driver); \
if (ret < 0) \
spi_unregister_driver(&fbtft_driver_spi_driver); \
return ret; \
} \
\
static void __exit fbtft_driver_module_exit(void) \
{ \
spi_unregister_driver(&fbtft_driver_spi_driver); \
platform_driver_unregister(&fbtft_driver_platform_driver); \
} \
\
module_init(fbtft_driver_module_init); \
module_exit(fbtft_driver_module_exit);
/********************************************************平台总线判断结束*****************************************************************/
/**********************************************************其他文件得函数***********************************************************************************/
/* fbtft-core.c */
int fbtft_write_buf_dc(struct fbtft_par *par, void *buf, size_t len, int dc);
// __printf(5, 6)
void fbtft_dbg_hex(const struct device *dev, int groupsize,
void *buf, size_t len, const char *fmt, ...);
struct fb_info *fbtft_framebuffer_alloc(struct fbtft_display *display,
struct device *dev,
struct fbtft_platform_data *pdata);
void fbtft_framebuffer_release(struct fb_info *info);
int fbtft_register_framebuffer(struct fb_info *fb_info);
int fbtft_unregister_framebuffer(struct fb_info *fb_info);
void fbtft_register_backlight(struct fbtft_par *par);
void fbtft_unregister_backlight(struct fbtft_par *par);
int fbtft_init_display(struct fbtft_par *par);
int fbtft_probe_common(struct fbtft_display *display, struct spi_device *sdev,
struct platform_device *pdev);
int fbtft_remove_common(struct device *dev, struct fb_info *info);
/* fbtft-io.c */
int fbtft_write_spi(struct fbtft_par *par, void *buf, size_t len);
int fbtft_write_spi_emulate_9(struct fbtft_par *par, void *buf, size_t len);
int fbtft_read_spi(struct fbtft_par *par, void *buf, size_t len);
int fbtft_write_gpio8_wr(struct fbtft_par *par, void *buf, size_t len);
int fbtft_write_gpio16_wr(struct fbtft_par *par, void *buf, size_t len);
int fbtft_write_gpio16_wr_latched(struct fbtft_par *par, void *buf, size_t len);
/* fbtft-bus.c */
int fbtft_write_vmem8_bus8(struct fbtft_par *par, size_t offset, size_t len);
int fbtft_write_vmem16_bus16(struct fbtft_par *par, size_t offset, size_t len);
int fbtft_write_vmem16_bus8(struct fbtft_par *par, size_t offset, size_t len);
int fbtft_write_vmem16_bus9(struct fbtft_par *par, size_t offset, size_t len);
void fbtft_write_reg8_bus8(struct fbtft_par *par, int len, ...);
void fbtft_write_reg8_bus9(struct fbtft_par *par, int len, ...);
void fbtft_write_reg16_bus8(struct fbtft_par *par, int len, ...);
void fbtft_write_reg16_bus16(struct fbtft_par *par, int len, ...);
/***********************************************************其他文件得函数结束************************************************************/
/**********************************特殊宏*********************************************************************/
void fbtft_sysfs_init(struct fbtft_par *par);
void fbtft_sysfs_exit(struct fbtft_par *par);
void fbtft_expand_debug_value(unsigned long *debug);
int fbtft_gamma_parse_str(struct fbtft_par *par, u32 *curves,
const char *str, int size);
#define FBTFT_ONBOARD_BACKLIGHT 2
#define FBTFT_GPIO_NO_MATCH 0xFFFF
#define FBTFT_GPIO_NAME_SIZE 32
#define FBTFT_MAX_INIT_SEQUENCE 512
#define FBTFT_GAMMA_MAX_VALUES_TOTAL 128
#define FBTFT_OF_INIT_CMD BIT(24)
#define FBTFT_OF_INIT_DELAY BIT(25)
/* Debug macros */
/* shorthand debug levels */
#define DEBUG_LEVEL_1 DEBUG_REQUEST_GPIOS
#define DEBUG_LEVEL_2 (DEBUG_LEVEL_1 | DEBUG_DRIVER_INIT_FUNCTIONS \
| DEBUG_TIME_FIRST_UPDATE)
#define DEBUG_LEVEL_3 (DEBUG_LEVEL_2 | DEBUG_RESET | DEBUG_INIT_DISPLAY \
| DEBUG_BLANK | DEBUG_REQUEST_GPIOS \
| DEBUG_FREE_GPIOS \
| DEBUG_VERIFY_GPIOS \
| DEBUG_BACKLIGHT | DEBUG_SYSFS)
#define DEBUG_LEVEL_4 (DEBUG_LEVEL_2 | DEBUG_FB_READ | DEBUG_FB_WRITE \
| DEBUG_FB_FILLRECT \
| DEBUG_FB_COPYAREA \
| DEBUG_FB_IMAGEBLIT | DEBUG_FB_BLANK)
#define DEBUG_LEVEL_5 (DEBUG_LEVEL_3 | DEBUG_UPDATE_DISPLAY)
#define DEBUG_LEVEL_6 (DEBUG_LEVEL_4 | DEBUG_LEVEL_5)
#define DEBUG_LEVEL_7 0xFFFFFFFF
#define DEBUG_DRIVER_INIT_FUNCTIONS BIT(3)
#define DEBUG_TIME_FIRST_UPDATE BIT(4)
#define DEBUG_TIME_EACH_UPDATE BIT(5)
#define DEBUG_DEFERRED_IO BIT(6)
#define DEBUG_FBTFT_INIT_FUNCTIONS BIT(7)
/* fbops */
#define DEBUG_FB_READ BIT(8)
#define DEBUG_FB_WRITE BIT(9)
#define DEBUG_FB_FILLRECT BIT(10)
#define DEBUG_FB_COPYAREA BIT(11)
#define DEBUG_FB_IMAGEBLIT BIT(12)
#define DEBUG_FB_SETCOLREG BIT(13)
#define DEBUG_FB_BLANK BIT(14)
#define DEBUG_SYSFS BIT(16)
/* fbtftops */
#define DEBUG_BACKLIGHT BIT(17)
#define DEBUG_READ BIT(18)
#define DEBUG_WRITE BIT(19)
#define DEBUG_WRITE_VMEM BIT(20)
#define DEBUG_WRITE_REGISTER BIT(21)
#define DEBUG_SET_ADDR_WIN BIT(22)
#define DEBUG_RESET BIT(23)
#define DEBUG_MKDIRTY BIT(24)
#define DEBUG_UPDATE_DISPLAY BIT(25)
#define DEBUG_INIT_DISPLAY BIT(26)
#define DEBUG_BLANK BIT(27)
#define DEBUG_REQUEST_GPIOS BIT(28)
#define DEBUG_FREE_GPIOS BIT(29)
#define DEBUG_REQUEST_GPIOS_MATCH BIT(30)
#define DEBUG_VERIFY_GPIOS BIT(31)
/************************************宏值结束*******************************************************************/
/******************************************fbtft-core.c文件主要函数********************************************************************/
static unsigned long debug;
module_param(debug, ulong, 0000);
MODULE_PARM_DESC(debug, "override device debug level");
//向dc引脚写入数据
int fbtft_write_buf_dc(struct fbtft_par *par, void *buf, size_t len, int dc)
{
int ret;
gpiod_set_value(par->gpio.dc, dc);
ret = par->fbtftops.write(par, buf, len);
if (ret < 0)
dev_err(par->info->device,
"write() failed and returned %d\n", ret);
return ret;
}
//调试函数 fbtft_dbg_hex，用于将内存缓冲区中的数据以十六进制形式输出到日志中
void fbtft_dbg_hex(const struct device *dev, int groupsize,
void *buf, size_t len, const char *fmt, ...)
{
va_list args;
static char textbuf[512];
char *text = textbuf;
size_t text_len;
va_start(args, fmt);
text_len = vscnprintf(text, sizeof(textbuf), fmt, args);
va_end(args);
hex_dump_to_buffer(buf, len, 32, groupsize, text + text_len,
512 - text_len, false);
if (len > 32)
dev_info(dev, "%s ...\n", text);
else
dev_info(dev, "%s\n", text);
}
//获取gpio得状态并设置为有效
static int fbtft_request_one_gpio(struct fbtft_par *par,
const char *name, int index,
struct gpio_desc **gpiop)
{
struct device *dev = par->info->device;
struct device_node *node = dev->of_node;
int gpio, flags, ret = 0;
enum of_gpio_flags of_flags;
if (of_find_property(node, name, NULL)) {
gpio = of_get_named_gpio_flags(node, name, index, &of_flags);
if (gpio == -ENOENT)
return 0;
if (gpio == -EPROBE_DEFER)
return gpio;
if (gpio < 0) {
dev_err(dev,
"failed to get '%s' from DT\n", name);
return gpio;
}
//active low translates to initially low，如果gpio为低电平有效，就设置为低，否则设置为高
flags = (of_flags & OF_GPIO_ACTIVE_LOW) ? GPIOF_OUT_INIT_LOW :
GPIOF_OUT_INIT_HIGH;
ret = devm_gpio_request_one(dev, gpio, flags,
dev->driver->name);
if (ret) {
dev_err(dev,
"gpio_request_one('%s'=%d) failed with %d\n",
name, gpio, ret);
return ret;
}
*gpiop = gpio_to_desc(gpio);
fbtft_par_dbg(DEBUG_REQUEST_GPIOS, par, "%s: '%s' = GPIO%d\n",__func__, name, gpio);
}
return ret;
}
static int fbtft_request_gpios(struct fbtft_par *par)
{
int i;
int ret;
ret = fbtft_request_one_gpio(par, "reset", 0, &par->gpio.reset);
if (ret)
return ret;
ret = fbtft_request_one_gpio(par, "dc", 0, &par->gpio.dc);
if (ret)
return ret;
ret = fbtft_request_one_gpio(par, "rd", 0, &par->gpio.rd); //读取锁存信号
if (ret)
return ret;
ret = fbtft_request_one_gpio(par, "wr", 0, &par->gpio.wr);
if (ret)
return ret;
ret = fbtft_request_one_gpio(par, "cs", 0, &par->gpio.cs);
if (ret)
return ret;
ret = fbtft_request_one_gpio(par, "latch", 0, &par->gpio.latch); //锁存信号
if (ret)
return ret;
for (i = 0; i < 16; i++) {
ret = fbtft_request_one_gpio(par, "db", i, //并行数据总线
&par->gpio.db[i]);
if (ret)
return ret;
ret = fbtft_request_one_gpio(par, "led", i,
&par->gpio.led[i]); //led控制信号
if (ret)
return ret;
ret = fbtft_request_one_gpio(par, "aux", i, //辅助信号
&par->gpio.aux[i]);
if (ret)
return ret;
}
return 0;
}
//更新屏幕背光状态
static int fbtft_backlight_update_status(struct backlight_device *bd)
{
struct fbtft_par *par = bl_get_data(bd);
bool polarity = par->polarity;
fbtft_par_dbg(DEBUG_BACKLIGHT, par,
"%s: polarity=%d, power=%d, fb_blank=%d\n",
__func__, polarity, bd->props.power, bd->props.fb_blank);
if ((bd->props.power == FB_BLANK_UNBLANK) &&
(bd->props.fb_blank == FB_BLANK_UNBLANK))
gpiod_set_value(par->gpio.led[0], polarity);
else
gpiod_set_value(par->gpio.led[0], !polarity);
return 0;
}
//获取屏幕背光亮度
static int fbtft_backlight_get_brightness(struct backlight_device *bd)
{
return bd->props.brightness;
}
//注销屏幕背光设备
void fbtft_unregister_backlight(struct fbtft_par *par)
{
if (par->info->bl_dev) {
par->info->bl_dev->props.power = FB_BLANK_POWERDOWN;
backlight_update_status(par->info->bl_dev);
backlight_device_unregister(par->info->bl_dev);
par->info->bl_dev = NULL;
}
}
//背光设备的操作方法结构体
static const struct backlight_ops fbtft_bl_ops = {
.get_brightness = fbtft_backlight_get_brightness,
.update_status = fbtft_backlight_update_status,
};
//注册屏幕背光设备
void fbtft_register_backlight(struct fbtft_par *par)
{
struct backlight_device *bd;
struct backlight_properties bl_props = { 0, };
if (!par->gpio.led[0]) {
fbtft_par_dbg(DEBUG_BACKLIGHT, par,
"%s(): led pin not set, exiting.\n", __func__);
return;
}
bl_props.type = BACKLIGHT_RAW;
/* Assume backlight is off, get polarity from current state of pin */
bl_props.power = FB_BLANK_POWERDOWN;
if (!gpiod_get_value(par->gpio.led[0]))
par->polarity = true;
bd = backlight_device_register(dev_driver_string(par->info->device),
par->info->device, par,
&fbtft_bl_ops, &bl_props);
if (IS_ERR(bd)) {
dev_err(par->info->device,
"cannot register backlight device (%ld)\n",
PTR_ERR(bd));
return;
}
par->info->bl_dev = bd;
if (!par->fbtftops.unregister_backlight)
par->fbtftops.unregister_backlight = fbtft_unregister_backlight;
}
//设置tft显示屏的地址窗口，目的是在接下来写入数据操作只会影响该窗口内的像素区域
static void fbtft_set_addr_win(struct fbtft_par *par, int xs, int ys, int xe,
int ye)
{
write_reg(par, MIPI_DCS_SET_COLUMN_ADDRESS,
(xs >> 8) & 0xFF, xs & 0xFF, (xe >> 8) & 0xFF, xe & 0xFF);
write_reg(par, MIPI_DCS_SET_PAGE_ADDRESS,
(ys >> 8) & 0xFF, ys & 0xFF, (ye >> 8) & 0xFF, ye & 0xFF);
write_reg(par, MIPI_DCS_WRITE_MEMORY_START);
}
//复位屏幕
static void fbtft_reset(struct fbtft_par *par)
{
if (!par->gpio.reset)
return;
fbtft_par_dbg(DEBUG_RESET, par, "%s()\n", __func__);
gpiod_set_value_cansleep(par->gpio.reset, 0);
usleep_range(20, 40);
gpiod_set_value_cansleep(par->gpio.reset, 1);
msleep(120);
gpiod_set_value_cansleep(par->gpio.cs, 0); /* Activate chip *///函数用于设置 GPIO 引脚的值，并且在需要时允许在可以睡眠的上下文中运行。
}
//更新显示屏的内容，根据起始行和结束行的，将对应的显存内容写入到显示屏
static void fbtft_update_display(struct fbtft_par *par, unsigned int start_line,
unsigned int end_line)
{
size_t offset, len;
ktime_t ts_start, ts_end;
long fps, throughput;
bool timeit = false;
int ret = 0;
if (unlikely(par->debug & (DEBUG_TIME_FIRST_UPDATE |
DEBUG_TIME_EACH_UPDATE))) {
if ((par->debug & DEBUG_TIME_EACH_UPDATE) ||
((par->debug & DEBUG_TIME_FIRST_UPDATE) &&
!par->first_update_done)) {
ts_start = ktime_get();
timeit = true;
}
}
/* Sanity checks */
if (start_line > end_line) {
dev_warn(par->info->device,
"%s: start_line=%u is larger than end_line=%u. Shouldn't happen, will do full display update\n",
__func__, start_line, end_line);
start_line = 0;
end_line = par->info->var.yres - 1;
}
if (start_line > par->info->var.yres - 1 ||
end_line > par->info->var.yres - 1) {
dev_warn(par->info->device,
"%s: start_line=%u or end_line=%u is larger than max=%d. Shouldn't happen, will do full display update\n",
__func__, start_line,
end_line, par->info->var.yres - 1);
start_line = 0;
end_line = par->info->var.yres - 1;
}
fbtft_par_dbg(DEBUG_UPDATE_DISPLAY, par, "%s(start_line=%u, end_line=%u)\n",
__func__, start_line, end_line);
if (par->fbtftops.set_addr_win)
par->fbtftops.set_addr_win(par, 0, start_line,
par->info->var.xres - 1, end_line);
offset = start_line * par->info->fix.line_length;
len = (end_line - start_line + 1) * par->info->fix.line_length;
ret = par->fbtftops.write_vmem(par, offset, len);
if (ret < 0)
dev_err(par->info->device,
"%s: write_vmem failed to update display buffer\n",
__func__);
if (unlikely(timeit)) {
ts_end = ktime_get();
if (!ktime_to_ns(par->update_time))
par->update_time = ts_start;
fps = ktime_us_delta(ts_start, par->update_time);
par->update_time = ts_start;
fps = fps ? 1000000 / fps : 0;
throughput = ktime_us_delta(ts_end, ts_start);
throughput = throughput ? (len * 1000) / throughput : 0;
throughput = throughput * 1000 / 1024;
dev_info(par->info->device,
"Display update: %ld kB/s, fps=%ld\n",
throughput, fps);
par->first_update_done = true;
}
}
//标记显示屏的一部分区域为脏区域，表示该区域需要更新，并安排延迟工作来执行实际的显示更新
static void fbtft_mkdirty(struct fb_info *info, int y, int height)
{
struct fbtft_par *par = info->par;
struct fb_deferred_io *fbdefio = info->fbdefio;
/* special case, needed ? */
if (y == -1) {
y = 0;
height = info->var.yres;
}
/* Mark display lines/area as dirty */
spin_lock(&par->dirty_lock);
if (y < par->dirty_lines_start)
par->dirty_lines_start = y;
if (y + height - 1 > par->dirty_lines_end)
par->dirty_lines_end = y + height - 1;
spin_unlock(&par->dirty_lock);
/* Schedule deferred_io to update display (no-op if already on queue)*/
schedule_delayed_work(&info->deferred_work, fbdefio->delay);
}
//处理帧缓冲设备的延迟输入/输出，标记需要更新的显示区域，并调用更新显示函数
static void fbtft_deferred_io(struct fb_info *info, struct list_head *pagelist)
{
struct fbtft_par *par = info->par;
unsigned int dirty_lines_start, dirty_lines_end;
struct page *page;
unsigned long index;
unsigned int y_low = 0, y_high = 0;
int count = 0;
spin_lock(&par->dirty_lock);
dirty_lines_start = par->dirty_lines_start;
dirty_lines_end = par->dirty_lines_end;
/* set display line markers as clean */
par->dirty_lines_start = par->info->var.yres - 1;
par->dirty_lines_end = 0;
spin_unlock(&par->dirty_lock);
/* Mark display lines as dirty */
list_for_each_entry(page, pagelist, lru) {
count++;
index = page->index << PAGE_SHIFT;
y_low = index / info->fix.line_length;
y_high = (index + PAGE_SIZE - 1) / info->fix.line_length;
dev_dbg(info->device,
"page->index=%lu y_low=%d y_high=%d\n",
page->index, y_low, y_high);
if (y_high > info->var.yres - 1)
y_high = info->var.yres - 1;
if (y_low < dirty_lines_start)
dirty_lines_start = y_low;
if (y_high > dirty_lines_end)
dirty_lines_end = y_high;
}
par->fbtftops.update_display(info->par,
dirty_lines_start, dirty_lines_end);
}
//是用来处理帧缓冲设备中的填充矩形操作的函数，他会在显示屏指定区域内填充矩形，标记该区域为脏区域
//便于后续显示更新操作
static void fbtft_fb_fillrect(struct fb_info *info,
const struct fb_fillrect *rect)
{
struct fbtft_par *par = info->par;
dev_dbg(info->dev,
"%s: dx=%d, dy=%d, width=%d, height=%d\n",
__func__, rect->dx, rect->dy, rect->width, rect->height);
sys_fillrect(info, rect);
par->fbtftops.mkdirty(info, rect->dy, rect->height);
}
//用来处理帧缓冲设备中的区域复制操作，在指定区域执行复制操作，标记该区域是脏区域，方便后续操作
static void fbtft_fb_copyarea(struct fb_info *info,
const struct fb_copyarea *area)
{
struct fbtft_par *par = info->par;
dev_dbg(info->dev,
"%s: dx=%d, dy=%d, width=%d, height=%d\n",
__func__, area->dx, area->dy, area->width, area->height);
sys_copyarea(info, area);
par->fbtftops.mkdirty(info, area->dy, area->height);
}
//用来处理图像的位块操作，在指定区域绘制图像，标记区域为脏区域，后续执行更新
static void fbtft_fb_imageblit(struct fb_info *info,
const struct fb_image *image)
{
struct fbtft_par *par = info->par;
dev_dbg(info->dev,
"%s: dx=%d, dy=%d, width=%d, height=%d\n",
__func__, image->dx, image->dy, image->width, image->height);
sys_imageblit(info, image);
par->fbtftops.mkdirty(info, image->dy, image->height);
}
//设备中用于处理写操作的函数，写入用户空间的数据到帧缓冲设备，标记整个区域需要更新
static ssize_t fbtft_fb_write(struct fb_info *info, const char __user *buf,
size_t count, loff_t *ppos)
{
struct fbtft_par *par = info->par;
ssize_t res;
dev_dbg(info->dev,
"%s: count=%zd, ppos=%llu\n", __func__, count, *ppos);
res = fb_sys_write(info, buf, count, ppos);
/* TODO: only mark changed area update all for now */
par->fbtftops.mkdirty(info, -1, 0);
return res;
}
/* from pxafb.c */
//将通道值转换成一个帧缓冲的位字段值
static unsigned int chan_to_field(unsigned int chan, struct fb_bitfield *bf)
{
chan &= 0xffff;
chan >>= 16 - bf->length;
return chan << bf->offset;
}
//设置颜色寄存器的函数
static int fbtft_fb_setcolreg(unsigned int regno, unsigned int red,
unsigned int green, unsigned int blue,
unsigned int transp, struct fb_info *info)
{
unsigned int val;
int ret = 1;
dev_dbg(info->dev,
"%s(regno=%u, red=0x%X, green=0x%X, blue=0x%X, trans=0x%X)\n",
__func__, regno, red, green, blue, transp);
switch (info->fix.visual) {
case FB_VISUAL_TRUECOLOR:
if (regno < 16) {
u32 *pal = info->pseudo_palette;
val = chan_to_field(red, &info->var.red);
val |= chan_to_field(green, &info->var.green);
val |= chan_to_field(blue, &info->var.blue);
// val |= chan_to_field(red, &info->var.red);
// val |= chan_to_field(green, &info->var.green);
// val = chan_to_field(blue, &info->var.blue);
pal[regno] = val;
ret = 0;
}
break;
}
return ret;
}
//控制显示屏的空白状态（实现显示器的开关，挂起和恢复操作）
static int fbtft_fb_blank(int blank, struct fb_info *info)
{
struct fbtft_par *par = info->par;
int ret = -EINVAL;
dev_dbg(info->dev, "%s(blank=%d)\n",
__func__, blank);
if (!par->fbtftops.blank)
return ret;
switch (blank) {
case FB_BLANK_POWERDOWN:
case FB_BLANK_VSYNC_SUSPEND:
case FB_BLANK_HSYNC_SUSPEND:
case FB_BLANK_NORMAL:
ret = par->fbtftops.blank(par, true);
break;
case FB_BLANK_UNBLANK:
ret = par->fbtftops.blank(par, false);
break;
}
return ret;
}
//将struct fbtft_ops（src）结构体成员复制到另一个struct fbtft_ops（dts）结构体中
static void fbtft_merge_fbtftops(struct fbtft_ops *dst, struct fbtft_ops *src)
{
if (src->write)
dst->write = src->write;
if (src->read)
dst->read = src->read;
if (src->write_vmem)
dst->write_vmem = src->write_vmem;
if (src->write_register)
dst->write_register = src->write_register;
if (src->set_addr_win)
dst->set_addr_win = src->set_addr_win;
if (src->reset)
dst->reset = src->reset;
if (src->mkdirty)
dst->mkdirty = src->mkdirty;
if (src->update_display)
dst->update_display = src->update_display;
if (src->init_display)
dst->init_display = src->init_display;
if (src->blank)
dst->blank = src->blank;
if (src->request_gpios_match)
dst->request_gpios_match = src->request_gpios_match;
if (src->request_gpios)
dst->request_gpios = src->request_gpios;
if (src->verify_gpios)
dst->verify_gpios = src->verify_gpios;
if (src->register_backlight)
dst->register_backlight = src->register_backlight;
if (src->unregister_backlight)
dst->unregister_backlight = src->unregister_backlight;
if (src->set_var)
dst->set_var = src->set_var;
if (src->set_gamma)
dst->set_gamma = src->set_gamma;
}
/**
* fbtft_framebuffer_alloc - creates a new frame buffer info structure
* //创建一个新的帧缓冲区信息结构
*
* @display: pointer to structure describing the display
* 指向描述显示的结构的指针
* @dev: pointer to the device for this fb, this can be NULL
* 指向这个fb的设备指针，可以是null
* @pdata: platform data for the display in use
* 正在使用的显示器的平台数据
*
* Creates a new frame buffer info structure.
*
* Also creates and populates the following structures:
* 可以填充一下结构
* info->fbops
* info->fbdefio
* info->pseudo_palette
* par->fbtftops
* par->txbuf
*
* Returns the new structure, or NULL if an error occurred.
*
*/
struct fb_info *fbtft_framebuffer_alloc(struct fbtft_display *display,
struct device *dev,
struct fbtft_platform_data *pdata)
{
struct fb_info *info;
struct fbtft_par *par;
struct fb_ops *fbops = NULL;
struct fb_deferred_io *fbdefio = NULL;
u8 *vmem = NULL;
void *txbuf = NULL;
void *buf = NULL;
unsigned int width;
unsigned int height;
int txbuflen = display->txbuflen;
unsigned int bpp = display->bpp;
unsigned int fps = display->fps;
int vmem_size;
const s16 *init_sequence = display->init_sequence;
char *gamma = display->gamma;
u32 *gamma_curves = NULL;
/* sanity check */
//入参检查
if (display->gamma_num * display->gamma_len >
FBTFT_GAMMA_MAX_VALUES_TOTAL) {
dev_err(dev, "FBTFT_GAMMA_MAX_VALUES_TOTAL=%d is exceeded\n",
FBTFT_GAMMA_MAX_VALUES_TOTAL);
return NULL;
}
/* defaults */
//若没设置参数，则设置下列参数为默认参数
if (!fps) //帧率
fps = 20;
if (!bpp) //比特每像素
bpp = 16;
//bpp = 24;
if (!pdata) {
dev_err(dev, "platform data is missing\n");
return NULL;
}
/* override driver values? */
//覆盖驱动程序值？
if (pdata->fps)
fps = pdata->fps;
if (pdata->txbuflen)
txbuflen = pdata->txbuflen;
if (pdata->display.init_sequence)
init_sequence = pdata->display.init_sequence;
if (pdata->gamma)
gamma = pdata->gamma;
if (pdata->display.debug)
display->debug = pdata->display.debug;
if (pdata->display.backlight)
display->backlight = pdata->display.backlight;
if (pdata->display.width)
display->width = pdata->display.width;
if (pdata->display.height)
display->height = pdata->display.height;
if (pdata->display.buswidth)
display->buswidth = pdata->display.buswidth;
if (pdata->display.regwidth)
display->regwidth = pdata->display.regwidth;
display->debug |= debug;
fbtft_expand_debug_value(&display->debug);
//根据可能存在的角度调整长宽
switch (pdata->rotate) {
case 90:
case 270:
width = display->height;
height = display->width;
break;
default:
width = display->width;
height = display->height;
}
//分配内存
vmem_size = display->width * display->height * bpp / 8; //帧缓冲区的大小
vmem = vzalloc(vmem_size); //分配帧缓冲区
if (!vmem)
goto alloc_fail;
//分配fb_ops结构体的内存
fbops = devm_kzalloc(dev, sizeof(struct fb_ops), GFP_KERNEL);
if (!fbops)
goto alloc_fail;
//分配fb_deferred_io结构体的内存
fbdefio = devm_kzalloc(dev, sizeof(struct fb_deferred_io), GFP_KERNEL);
if (!fbdefio)
goto alloc_fail;
//分配临时缓冲区
buf = devm_kzalloc(dev, 128, GFP_KERNEL);
if (!buf)
goto alloc_fail;
//分配gamma曲线的内存
if (display->gamma_num && display->gamma_len) {
gamma_curves = devm_kcalloc(dev,
display->gamma_num *
display->gamma_len,
sizeof(gamma_curves[0]),
GFP_KERNEL);
if (!gamma_curves)
goto alloc_fail;
}
//分配帧缓冲设备
info = framebuffer_alloc(sizeof(struct fbtft_par), dev);
if (!info)
goto alloc_fail;
info->screen_buffer = vmem; //指向分配的显示缓冲区
info->fbops = fbops; //指向分配的fb_ops结构体，
//初始化其中的成员函数指针，这些函数包括读写、填充矩形、
//复制区域、图像传输、颜色寄存器设置和屏幕空白处理等。
info->fbdefio = fbdefio; //指向fb_deferred_io结构体，用于结构体的延迟和延迟处理函数
//初始化帧延迟I/O
fbops->owner = dev->driver->owner;
fbops->fb_read = fb_sys_read;
fbops->fb_write = fbtft_fb_write;
fbops->fb_fillrect = fbtft_fb_fillrect;
fbops->fb_copyarea = fbtft_fb_copyarea;
fbops->fb_imageblit = fbtft_fb_imageblit;
fbops->fb_setcolreg = fbtft_fb_setcolreg;
fbops->fb_blank = fbtft_fb_blank;
fbdefio->delay = HZ / fps;
fbdefio->deferred_io = fbtft_deferred_io;
fb_deferred_io_init(info);
//初始化结构体的固定参数
snprintf(info->fix.id, sizeof(info->fix.id), "%s", dev->driver->name);
info->fix.type = FB_TYPE_PACKED_PIXELS;
info->fix.visual = FB_VISUAL_TRUECOLOR;
info->fix.xpanstep = 0;
info->fix.ypanstep = 0;
info->fix.ywrapstep = 0;
info->fix.line_length = width * bpp / 8;
info->fix.accel = FB_ACCEL_NONE;
info->fix.smem_len = vmem_size;
//初始化结构体中的可变参数
info->var.rotate = pdata->rotate;
info->var.xres = width;
info->var.yres = height;
info->var.xres_virtual = info->var.xres;
info->var.yres_virtual = info->var.yres;
info->var.bits_per_pixel = bpp;
info->var.nonstd = 1;
// /* RGB565 *///红蓝反了
// info->var.red.offset = 0;
// info->var.red.length = 5;
// info->var.green.offset = 5;
// info->var.green.length = 6;
// info->var.blue.offset = 11;
// info->var.blue.length = 5;
// info->var.transp.offset = 0;
// info->var.transp.length = 0;
/* RGB565 *///红蓝反了
info->var.red.offset = 11;
info->var.red.length = 5;
info->var.green.offset = 5;
info->var.green.length = 6;
info->var.blue.offset = 0;
info->var.blue.length = 5;
info->var.transp.offset = 0;
info->var.transp.length = 0;
info->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB;
//初始化par结构体的各项参数，如调试标志，缓冲区指针，旋转角度，gamma曲线
par = info->par;
par->info = info;
par->pdata = pdata;
par->debug = display->debug;
par->buf = buf;
spin_lock_init(&par->dirty_lock);
//par->bgr = pdata->bgr;
par->bgr = 1;
par->startbyte = pdata->startbyte;
par->init_sequence = init_sequence;
par->gamma.curves = gamma_curves;
par->gamma.num_curves = display->gamma_num;
par->gamma.num_values = display->gamma_len;
mutex_init(&par->gamma.lock);
info->pseudo_palette = par->pseudo_palette;
if (par->gamma.curves && gamma) {
if (fbtft_gamma_parse_str(par, par->gamma.curves, gamma,
strlen(gamma)))
goto release_framebuf;
}
/* Transmit buffer */
if (txbuflen == -1)
txbuflen = vmem_size + 2; /* add in case startbyte is used */
if (txbuflen >= vmem_size + 2)
txbuflen = 0;
#ifdef __LITTLE_ENDIAN
if ((!txbuflen) && (bpp > 8))
txbuflen = PAGE_SIZE; /* need buffer for byteswapping */
#endif
if (txbuflen > 0) {
txbuf = devm_kzalloc(par->info->device, txbuflen, GFP_KERNEL);
if (!txbuf)
goto release_framebuf;
par->txbuf.buf = txbuf;
par->txbuf.len = txbuflen;
}
/* default fbtft operations */
//初始化fbtftops结构体，包括写入数据、读取数据、更新显示等默认的驱动操作函数
par->fbtftops.write = fbtft_write_spi;
par->fbtftops.read = fbtft_read_spi;
par->fbtftops.write_vmem = fbtft_write_vmem16_bus8;
par->fbtftops.write_register = fbtft_write_reg8_bus8;
par->fbtftops.set_addr_win = fbtft_set_addr_win;
par->fbtftops.reset = fbtft_reset;
par->fbtftops.mkdirty = fbtft_mkdirty;
par->fbtftops.update_display = fbtft_update_display;
if (display->backlight)
par->fbtftops.register_backlight = fbtft_register_backlight;
/* use driver provided functions */
fbtft_merge_fbtftops(&par->fbtftops, &display->fbtftops);
return info;
release_framebuf:
framebuffer_release(info);
alloc_fail:
vfree(vmem);
return NULL;
}
/**
* fbtft_framebuffer_release - frees up all memory used by the framebuffer
* 释放framebuffer使用的所以内存
*
* @info: frame buffer info structure
*
*/
void fbtft_framebuffer_release(struct fb_info *info)
{
fb_deferred_io_cleanup(info);
vfree(info->screen_buffer);
framebuffer_release(info);
}
/**
* fbtft_register_framebuffer - registers a tft frame buffer device
* @fb_info: frame buffer info structure
*注册一个帧缓冲设备
* Sets SPI driverdata if needed 如果需要，设置spi驱动程序数据
* Requests needed gpios. 注册需要的gpio
* Initializes display 初始化显示
* Updates display. 更新显示
* Registers a frame buffer device @fb_info.注册一个帧缓冲设备
*
* Returns negative errno on error, or zero for success.
*
*/
int fbtft_register_framebuffer(struct fb_info *fb_info)
{
int ret;
char text1[50] = "";
char text2[50] = "";
struct fbtft_par *par = fb_info->par;
struct spi_device *spi = par->spi;
/* sanity checks */ //安全检查
if (!par->fbtftops.init_display) {
dev_err(fb_info->device, "missing fbtftops.init_display()\n");
return -EINVAL;
}
if (spi)
spi_set_drvdata(spi, fb_info);
if (par->pdev)
platform_set_drvdata(par->pdev, fb_info);
ret = par->fbtftops.request_gpios(par);
if (ret < 0)
goto reg_fail;
if (par->fbtftops.verify_gpios) {
ret = par->fbtftops.verify_gpios(par);
if (ret < 0)
goto reg_fail;
}
ret = par->fbtftops.init_display(par);
if (ret < 0)
goto reg_fail;
if (par->fbtftops.set_var) {
ret = par->fbtftops.set_var(par);
if (ret < 0)
goto reg_fail;
}
/* update the entire display */
par->fbtftops.update_display(par, 0, par->info->var.yres - 1);
if (par->fbtftops.set_gamma && par->gamma.curves) {
ret = par->fbtftops.set_gamma(par, par->gamma.curves);
if (ret)
goto reg_fail;
}
if (par->fbtftops.register_backlight)
par->fbtftops.register_backlight(par);
printk("匹配已经成功，开始注册framebuffer函数，生成设备号\n");
ret = register_framebuffer(fb_info); //注册framebuffer驱动，这时空间已经分配完成
if (ret < 0)
goto reg_fail;
printk("生成设备号成功\n");
fbtft_sysfs_init(par);
printk("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n");
printk("打印输出的bgr[%d]\n",par->bgr);
if (par->txbuf.buf && par->txbuf.len >= 1024)
sprintf(text1, ", %zu KiB buffer memory", par->txbuf.len >> 10);
if (spi)
sprintf(text2, ", spi%d.%d at %d MHz", spi->master->bus_num,
spi->chip_select, spi->max_speed_hz / 1000000);
dev_info(fb_info->dev,
"%s frame buffer, %dx%d, %d KiB video memory%s, fps=%lu%s\n",
fb_info->fix.id, fb_info->var.xres, fb_info->var.yres,
fb_info->fix.smem_len >> 10, text1,
HZ / fb_info->fbdefio->delay, text2);
/* Turn on backlight if available */
if (fb_info->bl_dev) {
fb_info->bl_dev->props.power = FB_BLANK_UNBLANK;
fb_info->bl_dev->ops->update_status(fb_info->bl_dev);
}
return 0;
reg_fail:
if (par->fbtftops.unregister_backlight)
par->fbtftops.unregister_backlight(par);
return ret;
}
/**
* fbtft_unregister_framebuffer - releases a tft frame buffer device
释放tft帧缓冲设备
* @fb_info: frame buffer info structure
*
* Frees SPI driverdata if needed
* Frees gpios.
* Unregisters frame buffer device.
*
*/
int fbtft_unregister_framebuffer(struct fb_info *fb_info)
{
struct fbtft_par *par = fb_info->par;
if (par->fbtftops.unregister_backlight)
par->fbtftops.unregister_backlight(par);
fbtft_sysfs_exit(par);
unregister_framebuffer(fb_info);
return 0;
}
/**
* fbtft_init_display_from_property() - Device Tree init_display() function
* @par: Driver data
* 从设备树属性初始化显示设备
*
* Return: 0 if successful, negative if error
*/
static int fbtft_init_display_from_property(struct fbtft_par *par)
{
struct device *dev = par->info->device;
int buf[64], count, index, i, j, ret;
u32 *values;
u32 val;
count = device_property_count_u32(dev, "init");
if (count < 0)
return count;
if (count == 0)
return -EINVAL;
values = kmalloc_array(count + 1, sizeof(*values), GFP_KERNEL);
if (!values)
return -ENOMEM;
ret = device_property_read_u32_array(dev, "init", values, count);
if (ret)
goto out_free;
par->fbtftops.reset(par);
index = -1;
val = values[++index];
while (index < count) {
if (val & FBTFT_OF_INIT_CMD) {
val &= 0xFFFF;
i = 0;
while ((index < count) && !(val & 0xFFFF0000)) {
if (i > 63) {
dev_err(dev,
"%s: Maximum register values exceeded\n",
__func__);
ret = -EINVAL;
goto out_free;
}
buf[i++] = val;
val = values[++index];
}
/* make debug message */
fbtft_par_dbg(DEBUG_INIT_DISPLAY, par,
"init: write_register:\n");
for (j = 0; j < i; j++)
fbtft_par_dbg(DEBUG_INIT_DISPLAY, par,
"buf[%d] = %02X\n", j, buf[j]);
par->fbtftops.write_register(par, i,
buf[0], buf[1], buf[2], buf[3],
buf[4], buf[5], buf[6], buf[7],
buf[8], buf[9], buf[10], buf[11],
buf[12], buf[13], buf[14], buf[15],
buf[16], buf[17], buf[18], buf[19],
buf[20], buf[21], buf[22], buf[23],
buf[24], buf[25], buf[26], buf[27],
buf[28], buf[29], buf[30], buf[31],
buf[32], buf[33], buf[34], buf[35],
buf[36], buf[37], buf[38], buf[39],
buf[40], buf[41], buf[42], buf[43],
buf[44], buf[45], buf[46], buf[47],
buf[48], buf[49], buf[50], buf[51],
buf[52], buf[53], buf[54], buf[55],
buf[56], buf[57], buf[58], buf[59],
buf[60], buf[61], buf[62], buf[63]);
} else if (val & FBTFT_OF_INIT_DELAY) {
fbtft_par_dbg(DEBUG_INIT_DISPLAY, par,
"init: msleep(%u)\n", val & 0xFFFF);
msleep(val & 0xFFFF);
val = values[++index];
} else {
dev_err(dev, "illegal init value 0x%X\n", val);
ret = -EINVAL;
goto out_free;
}
}
out_free:
kfree(values);
return ret;
}
/**
* fbtft_init_display() - Generic init_display() function
* 通用的显示设备初始化函数，根据设备fbtft_par中的init_sequence数组来执行初始化序列
* @par: Driver data
*
* Uses par->init_sequence to do the initialization
*
* Return: 0 if successful, negative if error
*/
int fbtft_init_display(struct fbtft_par *par)
{
int buf[64];
char msg[128];
char str[16];
int i = 0;
int j;
/* sanity check */
if (!par->init_sequence) {
dev_err(par->info->device,
"error: init_sequence is not set\n");
return -EINVAL;
}
/* make sure stop marker exists */
for (i = 0; i < FBTFT_MAX_INIT_SEQUENCE; i++)
if (par->init_sequence[i] == -3)
break;
if (i == FBTFT_MAX_INIT_SEQUENCE) {
dev_err(par->info->device,
"missing stop marker at end of init sequence\n");
return -EINVAL;
}
par->fbtftops.reset(par);
i = 0;
while (i < FBTFT_MAX_INIT_SEQUENCE) {
if (par->init_sequence[i] == -3) {
/* done */
return 0;
}
if (par->init_sequence[i] >= 0) {
dev_err(par->info->device,
"missing delimiter at position %d\n", i);
return -EINVAL;
}
if (par->init_sequence[i + 1] < 0) {
dev_err(par->info->device,
"missing value after delimiter %d at position %d\n",
par->init_sequence[i], i);
return -EINVAL;
}
switch (par->init_sequence[i]) {
case -1:
i++;
/* make debug message */
strcpy(msg, "");
j = i + 1;
while (par->init_sequence[j] >= 0) {
sprintf(str, "0x%02X ", par->init_sequence[j]);
strcat(msg, str);
j++;
}
fbtft_par_dbg(DEBUG_INIT_DISPLAY, par,
"init: write(0x%02X) %s\n",
par->init_sequence[i], msg);
/* Write */
j = 0;
while (par->init_sequence[i] >= 0) {
if (j > 63) {
dev_err(par->info->device,
"%s: Maximum register values exceeded\n",
__func__);
return -EINVAL;
}
buf[j++] = par->init_sequence[i++];
}
par->fbtftops.write_register(par, j,
buf[0], buf[1], buf[2], buf[3],
buf[4], buf[5], buf[6], buf[7],
buf[8], buf[9], buf[10], buf[11],
buf[12], buf[13], buf[14], buf[15],
buf[16], buf[17], buf[18], buf[19],
buf[20], buf[21], buf[22], buf[23],
buf[24], buf[25], buf[26], buf[27],
buf[28], buf[29], buf[30], buf[31],
buf[32], buf[33], buf[34], buf[35],
buf[36], buf[37], buf[38], buf[39],
buf[40], buf[41], buf[42], buf[43],
buf[44], buf[45], buf[46], buf[47],
buf[48], buf[49], buf[50], buf[51],
buf[52], buf[53], buf[54], buf[55],
buf[56], buf[57], buf[58], buf[59],
buf[60], buf[61], buf[62], buf[63]);
break;
case -2:
i++;
fbtft_par_dbg(DEBUG_INIT_DISPLAY, par,
"init: mdelay(%d)\n",
par->init_sequence[i]);
mdelay(par->init_sequence[i++]);
break;
default:
dev_err(par->info->device,
"unknown delimiter %d at position %d\n",
par->init_sequence[i], i);
return -EINVAL;
}
}
dev_err(par->info->device,
"%s: something is wrong. Shouldn't get here.\n", __func__);
return -EINVAL;
}
/**
* fbtft_verify_gpios() - Generic verify_gpios() function
* 通用初始化函数，用于帧缓冲设备驱动中的设备初始化过程
* @par: Driver data
*
* Uses @spi, @pdev and @buswidth to determine which GPIOs is needed
*
* Return: 0 if successful, negative if error
*/
static int fbtft_verify_gpios(struct fbtft_par *par)
{
struct fbtft_platform_data *pdata = par->pdata;
int i;
fbtft_par_dbg(DEBUG_VERIFY_GPIOS, par, "%s()\n", __func__);
if (pdata->display.buswidth != 9 && par->startbyte == 0 &&
!par->gpio.dc) {
dev_err(par->info->device,
"Missing info about 'dc' gpio. Aborting.\n");
return -EINVAL;
}
if (!par->pdev)
return 0;
if (!par->gpio.wr) {
dev_err(par->info->device, "Missing 'wr' gpio. Aborting.\n");
return -EINVAL;
}
for (i = 0; i < pdata->display.buswidth; i++) {
if (!par->gpio.db[i]) {
dev_err(par->info->device,
"Missing 'db%02d' gpio. Aborting.\n", i);
return -EINVAL;
}
}
return 0;
}
/* returns 0 if the property is not present */
//从设备的属性中读取一个无符号的32位整数
static u32 fbtft_property_value(struct device *dev, const char *propname)
{
int ret;
u32 val = 0;
ret = device_property_read_u32(dev, propname, &val);
if (ret == 0)
dev_info(dev, "%s: %s = %u\n", __func__, propname, val);
return val;
}
//从设备的属性中读取信息，填充到fbtft_platform_data结构体中
static struct fbtft_platform_data *fbtft_properties_read(struct device *dev)
{
struct fbtft_platform_data *pdata;
if (!dev_fwnode(dev)) {
dev_err(dev, "Missing platform data or properties\n");
return ERR_PTR(-EINVAL);
}
pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata)
return ERR_PTR(-ENOMEM);
pdata->display.width = fbtft_property_value(dev, "width");
pdata->display.height = fbtft_property_value(dev, "height");
pdata->display.regwidth = fbtft_property_value(dev, "regwidth");
pdata->display.buswidth = fbtft_property_value(dev, "buswidth");
pdata->display.backlight = fbtft_property_value(dev, "backlight");
pdata->display.bpp = fbtft_property_value(dev, "bpp");
pdata->display.debug = fbtft_property_value(dev, "debug");
pdata->rotate = fbtft_property_value(dev, "rotate");
pdata->bgr = device_property_read_bool(dev, "bgr");
pdata->fps = fbtft_property_value(dev, "fps");
pdata->txbuflen = fbtft_property_value(dev, "txbuflen");
pdata->startbyte = fbtft_property_value(dev, "startbyte");
device_property_read_string(dev, "gamma", (const char **)&pdata->gamma);
if (device_property_present(dev, "led-gpios"))
pdata->display.backlight = 1;
if (device_property_present(dev, "init"))
pdata->display.fbtftops.init_display =
fbtft_init_display_from_property;
pdata->display.fbtftops.request_gpios = fbtft_request_gpios;
return pdata;
}
/*****************************************************fbtft-core.c文件主要函数结束********************************************************/
/********************************************************fbtft-sysfs.c文件函数开始**************************************************************/
static int get_next_ulong(char **str_p, unsigned long *val, char *sep, int base)
{
char *p_val;
if (!str_p || !(*str_p))
return -EINVAL;
p_val = strsep(str_p, sep);
if (!p_val)
return -EINVAL;
return kstrtoul(p_val, base, val);
}
int fbtft_gamma_parse_str(struct fbtft_par *par, u32 *curves,
const char *str, int size)
{
char *str_p, *curve_p = NULL;
char *tmp;
unsigned long val = 0;
int ret = 0;
int curve_counter, value_counter;
int _count;
fbtft_par_dbg(DEBUG_SYSFS, par, "%s() str=\n", __func__);
if (!str || !curves)
return -EINVAL;
fbtft_par_dbg(DEBUG_SYSFS, par, "%s\n", str);
tmp = kmemdup(str, size + 1, GFP_KERNEL);
if (!tmp)
return -ENOMEM;
/* replace optional separators */
str_p = tmp;
while (*str_p) {
if (*str_p == ',')
*str_p = ' ';
if (*str_p == ';')
*str_p = '\n';
str_p++;
}
str_p = strim(tmp);
curve_counter = 0;
while (str_p) {
if (curve_counter == par->gamma.num_curves) {
dev_err(par->info->device, "Gamma: Too many curves\n");
ret = -EINVAL;
goto out;
}
curve_p = strsep(&str_p, "\n");
value_counter = 0;
while (curve_p) {
if (value_counter == par->gamma.num_values) {
dev_err(par->info->device,
"Gamma: Too many values\n");
ret = -EINVAL;
goto out;
}
ret = get_next_ulong(&curve_p, &val, " ", 16);
if (ret)
goto out;
_count = curve_counter * par->gamma.num_values +
value_counter;
curves[_count] = val;
value_counter++;
}
if (value_counter != par->gamma.num_values) {
dev_err(par->info->device, "Gamma: Too few values\n");
ret = -EINVAL;
goto out;
}
curve_counter++;
}
if (curve_counter != par->gamma.num_curves) {
dev_err(par->info->device, "Gamma: Too few curves\n");
ret = -EINVAL;
goto out;
}
out:
kfree(tmp);
return ret;
}
static ssize_t
sprintf_gamma(struct fbtft_par *par, u32 *curves, char *buf)
{
ssize_t len = 0;
unsigned int i, j;
mutex_lock(&par->gamma.lock);
for (i = 0; i < par->gamma.num_curves; i++) {
for (j = 0; j < par->gamma.num_values; j++)
len += scnprintf(&buf[len], PAGE_SIZE,
"%04x ", curves[i * par->gamma.num_values + j]);
buf[len - 1] = '\n';
}
mutex_unlock(&par->gamma.lock);
return len;
}
static ssize_t store_gamma_curve(struct device *device,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct fb_info *fb_info = dev_get_drvdata(device);
struct fbtft_par *par = fb_info->par;
u32 tmp_curves[FBTFT_GAMMA_MAX_VALUES_TOTAL];
int ret;
ret = fbtft_gamma_parse_str(par, tmp_curves, buf, count);
if (ret)
return ret;
ret = par->fbtftops.set_gamma(par, tmp_curves);
if (ret)
return ret;
mutex_lock(&par->gamma.lock);
memcpy(par->gamma.curves, tmp_curves,
par->gamma.num_curves * par->gamma.num_values *
sizeof(tmp_curves[0]));
mutex_unlock(&par->gamma.lock);
return count;
}
static ssize_t show_gamma_curve(struct device *device,
struct device_attribute *attr, char *buf)
{
struct fb_info *fb_info = dev_get_drvdata(device);
struct fbtft_par *par = fb_info->par;
return sprintf_gamma(par, par->gamma.curves, buf);
}
static struct device_attribute gamma_device_attrs[] = {
__ATTR(gamma, 0660, show_gamma_curve, store_gamma_curve),
};
void fbtft_expand_debug_value(unsigned long *debug)
{
switch (*debug & 0x7) {
case 1:
*debug |= DEBUG_LEVEL_1;
break;
case 2:
*debug |= DEBUG_LEVEL_2;
break;
case 3:
*debug |= DEBUG_LEVEL_3;
break;
case 4:
*debug |= DEBUG_LEVEL_4;
break;
case 5:
*debug |= DEBUG_LEVEL_5;
break;
case 6:
*debug |= DEBUG_LEVEL_6;
break;
case 7:
*debug = 0xFFFFFFFF;
break;
}
}
static ssize_t store_debug(struct device *device,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct fb_info *fb_info = dev_get_drvdata(device);
struct fbtft_par *par = fb_info->par;
int ret;
ret = kstrtoul(buf, 10, &par->debug);
if (ret)
return ret;
fbtft_expand_debug_value(&par->debug);
return count;
}
static ssize_t show_debug(struct device *device,
struct device_attribute *attr, char *buf)
{
struct fb_info *fb_info = dev_get_drvdata(device);
struct fbtft_par *par = fb_info->par;
return snprintf(buf, PAGE_SIZE, "%lu\n", par->debug);
}
static struct device_attribute debug_device_attr =
__ATTR(debug, 0660, show_debug, store_debug);
void fbtft_sysfs_init(struct fbtft_par *par)
{
device_create_file(par->info->dev, &debug_device_attr);
if (par->gamma.curves && par->fbtftops.set_gamma)
device_create_file(par->info->dev, &gamma_device_attrs[0]);
}
void fbtft_sysfs_exit(struct fbtft_par *par)
{
device_remove_file(par->info->dev, &debug_device_attr);
if (par->gamma.curves && par->fbtftops.set_gamma)
device_remove_file(par->info->dev, &gamma_device_attrs[0]);
}
/********************************************************fbtft-sysfs.c文件函数结束**************************************************************/
/**********************************************************fbtft-bus.c文件的开始*****************************************************************/
/*****************************************************************************
*
* void (*write_reg)(struct fbtft_par *par, int len, ...);
*
*****************************************************************************/
define_fbtft_write_reg(fbtft_write_reg8_bus8, u8, u8, )
define_fbtft_write_reg(fbtft_write_reg16_bus8, __be16, u16, cpu_to_be16)
define_fbtft_write_reg(fbtft_write_reg16_bus16, u16, u16, )
void fbtft_write_reg8_bus9(struct fbtft_par *par, int len, ...)
{
va_list args;
int i, ret;
int pad = 0;
u16 *buf = (u16 *)par->buf;
if (unlikely(par->debug & DEBUG_WRITE_REGISTER)) {
va_start(args, len);
for (i = 0; i < len; i++)
*(((u8 *)buf) + i) = (u8)va_arg(args, unsigned int);
va_end(args);
fbtft_par_dbg_hex(DEBUG_WRITE_REGISTER, par,
par->info->device, u8, buf, len, "%s: ",
__func__);
}
if (len <= 0)
return;
if (par->spi && (par->spi->bits_per_word == 8)) {
/* we're emulating 9-bit, pad start of buffer with no-ops
* (assuming here that zero is a no-op)
*/
pad = (len % 4) ? 4 - (len % 4) : 0;
for (i = 0; i < pad; i++)
*buf++ = 0x000;
}
va_start(args, len);
*buf++ = (u8)va_arg(args, unsigned int);
i = len - 1;
while (i--) {
*buf = (u8)va_arg(args, unsigned int);
*buf++ |= 0x100; /* dc=1 */
}
va_end(args);
ret = par->fbtftops.write(par, par->buf, (len + pad) * sizeof(u16));
if (ret < 0) {
dev_err(par->info->device,
"write() failed and returned %d\n", ret);
return;
}
}
/*****************************************************************************
*
* int (*write_vmem)(struct fbtft_par *par);
*
*****************************************************************************/
/* 16 bit pixel over 8-bit databus */
int fbtft_write_vmem16_bus8(struct fbtft_par *par, size_t offset, size_t len)
{
// u8 *vmem8;
// u8 *txbuf8 = par->txbuf.buf;
// size_t remain;
// size_t to_copy;
// size_t tx_array_size;
// int i;
// int ret = 0;
// size_t startbyte_size = 0;
// fbtft_par_dbg(DEBUG_WRITE_VMEM, par, "%s(offset=%zu, len=%zu)\n",
// __func__, offset, len);
// remain = len;
// vmem8 = (u8 *)(par->info->screen_buffer + offset);
// gpiod_set_value(par->gpio.dc, 1);
// /* non buffered write */
// if (!par->txbuf.buf)
// return par->fbtftops.write(par, vmem8, len);
// /* buffered write */
// tx_array_size = par->txbuf.len;
// if (par->startbyte) {
// txbuf8 = par->txbuf.buf + 1;
// tx_array_size -= 1;
// *(u8 *)(par->txbuf.buf) = par->startbyte | 0x2;
// startbyte_size = 1;
// }
// while (remain) {
// to_copy = min(tx_array_size, remain);
// dev_dbg(par->info->device, "to_copy=%zu, remain=%zu\n",
// to_copy, remain - to_copy);
// for (i = 0; i < to_copy; i++)
// {
// txbuf16[i] = cpu_to_be16(vmem16[i]);
// // printk("转换字节序aaaaaaaaa\n");
// }
// // for (i = 0; i < to_copy; i++)
// // {
// // txbuf16[i] = be16_to_cpu(vmem16[i]);
// // printk("转换字节序bbbbbbbbbbbbb\n");
// // }
// for (i = 0; i < to_copy; i++)
// {
// //txbuf16[i] = vmem16[i];
// txbuf8[i] = vmem8[i]; // R
// txbuf8[i + 1] = vmem8[i + 1]; // G
// txbuf8[i + 2] = vmem8[i + 2]; // B
// // printk("转换字节序cccccccccc\n");
// }
// vmem8 = vmem8 + to_copy;
// ret = par->fbtftops.write(par, par->txbuf.buf,
// startbyte_size + to_copy);
// // ret = par->fbtftops.write(par, vmem8,
// // startbyte_size + to_copy);
// if (ret < 0)
// return ret;
// remain -= to_copy;
//}
u16 *vmem16;
__be16 *txbuf16 = par->txbuf.buf;
size_t remain;
size_t to_copy;
size_t tx_array_size;
int i;
int ret = 0;
size_t startbyte_size = 0;
fbtft_par_dbg(DEBUG_WRITE_VMEM, par, "%s(offset=%zu, len=%zu)\n",
__func__, offset, len);
remain = len / 2;
vmem16 = (u16 *)(par->info->screen_buffer + offset);
gpiod_set_value(par->gpio.dc, 1);
/* non buffered write */
if (!par->txbuf.buf)
return par->fbtftops.write(par, vmem16, len);
/* buffered write */
tx_array_size = par->txbuf.len / 2;
if (par->startbyte) {
txbuf16 = par->txbuf.buf + 1;
tx_array_size -= 2;
*(u8 *)(par->txbuf.buf) = par->startbyte | 0x2;
startbyte_size = 1;
}
while (remain) {
to_copy = min(tx_array_size, remain);
dev_dbg(par->info->device, "to_copy=%zu, remain=%zu\n",
to_copy, remain - to_copy);
for (i = 0; i < to_copy; i++)
{
txbuf16[i] = cpu_to_be16(vmem16[i]);
// printk("转换字节序aaaaaaaaa\n");
}
// for (i = 0; i < to_copy; i++)
// {
// txbuf16[i] = be16_to_cpu(vmem16[i]);
// printk("转换字节序bbbbbbbbbbbbb\n");
// }
// for (i = 0; i < to_copy; i++)
// {
// txbuf16[i] = vmem16[i];
// // printk("转换字节序cccccccccc\n");
// }
vmem16 = vmem16 + to_copy;
ret = par->fbtftops.write(par, par->txbuf.buf,
startbyte_size + to_copy * 2);
if (ret < 0)
return ret;
remain -= to_copy;
}
return ret;
}
/* 16 bit pixel over 9-bit SPI bus: dc + high byte, dc + low byte */
int fbtft_write_vmem16_bus9(struct fbtft_par *par, size_t offset, size_t len)
{
u8 *vmem8;
u16 *txbuf16 = par->txbuf.buf;
size_t remain;
size_t to_copy;
size_t tx_array_size;
int i;
int ret = 0;
fbtft_par_dbg(DEBUG_WRITE_VMEM, par, "%s(offset=%zu, len=%zu)\n",
__func__, offset, len);
if (!par->txbuf.buf) {
dev_err(par->info->device, "%s: txbuf.buf is NULL\n", __func__);
return -1;
}
remain = len;
vmem8 = par->info->screen_buffer + offset;
tx_array_size = par->txbuf.len / 2;
while (remain) {
to_copy = min(tx_array_size, remain);
dev_dbg(par->info->device, "to_copy=%zu, remain=%zu\n",
to_copy, remain - to_copy);
#ifdef __LITTLE_ENDIAN
for (i = 0; i < to_copy; i += 2) {
txbuf16[i] = 0x0100 | vmem8[i + 1];
txbuf16[i + 1] = 0x0100 | vmem8[i];
}
#else
for (i = 0; i < to_copy; i++)
txbuf16[i] = 0x0100 | vmem8[i];
#endif
vmem8 = vmem8 + to_copy;
ret = par->fbtftops.write(par, par->txbuf.buf, to_copy * 2);
if (ret < 0)
return ret;
remain -= to_copy;
}
return ret;
}
int fbtft_write_vmem8_bus8(struct fbtft_par *par, size_t offset, size_t len)
{
dev_err(par->info->device, "%s: function not implemented\n", __func__);
return -1;
}
/* 16 bit pixel over 16-bit databus */
int fbtft_write_vmem16_bus16(struct fbtft_par *par, size_t offset, size_t len)
{
u16 *vmem16;
fbtft_par_dbg(DEBUG_WRITE_VMEM, par, "%s(offset=%zu, len=%zu)\n",
__func__, offset, len);
vmem16 = (u16 *)(par->info->screen_buffer + offset);
/* no need for buffered write with 16-bit bus */
return fbtft_write_buf_dc(par, vmem16, len, 1);
}
/*********************************************************fbtft-bus.c文件的结束****************************************************************/
/************************************************************fbtft-io.c文件的开始*****************************************************************/
int fbtft_write_spi(struct fbtft_par *par, void *buf, size_t len)
{
struct spi_transfer t = {
.tx_buf = buf,
.len = len,
};
struct spi_message m;
// uint32_t *color_buf = (uint32_t *)buf;
// size_t num_colors = len; // 每个颜色值是16位（2字节）
// size_t i = 0;
fbtft_par_dbg_hex(DEBUG_WRITE, par, par->info->device, u8, buf, len,
"%s(len=%zu): ", __func__, len);
if (!par->spi) {
dev_err(par->info->device,
"%s: par->spi is unexpectedly NULL\n", __func__);
return -1;
}
// printk("aaaaaaaaaaaaaa打印输出的颜色p[%p]\n",buf);
// // 打印颜色数据
// printk("颜色数据:\n");
// // for (i = 0; i < num_colors; i++) {
// printk("颜色[%zu]: 0x%08x\n", i, color_buf[50]);
// printk("颜色[%zu]: 0x%08x\n", i, color_buf[100]);
// printk("颜色[%zu]: 0x%08x\n", i, color_buf[150]);
// printk("颜色[%zu]: 0x%08x\n", i, color_buf[200]);
// printk("颜色[%zu]: 0x%08x\n", i, color_buf[250]);
// printk("颜色[%zu]: 0x%08x\n", i, color_buf[300]);
// printk("颜色[%zu]: 0x%08x\n", i, color_buf[350]);
// printk("打印输出的len[%d]\n",len);
// printk("打印输出的bpp[%d]\n",par->info->var.bits_per_pixel);
// printk("打印输出的bgr[%d]\n",par->bgr);
// printk("打印输出的rotate[%d]\n",par->info->var.rotate);
// // }
spi_message_init(&m);
spi_message_add_tail(&t, &m);
return spi_sync(par->spi, &m);
}
/**
* fbtft_write_spi_emulate_9() - write SPI emulating 9-bit
* @par: Driver data
* @buf: Buffer to write
* @len: Length of buffer (must be divisible by 8)
*
* When 9-bit SPI is not available, this function can be used to emulate that.
* par->extra must hold a transformation buffer used for transfer.
*/
int fbtft_write_spi_emulate_9(struct fbtft_par *par, void *buf, size_t len)
{
u16 *src = buf;
u8 *dst = par->extra;
size_t size = len / 2;
size_t added = 0;
int bits, i, j;
u64 val, dc, tmp;
fbtft_par_dbg_hex(DEBUG_WRITE, par, par->info->device, u8, buf, len,
"%s(len=%zu): ", __func__, len);
if (!par->extra) {
dev_err(par->info->device, "%s: error: par->extra is NULL\n",
__func__);
return -EINVAL;
}
if ((len % 8) != 0) {
dev_err(par->info->device,
"error: len=%zu must be divisible by 8\n", len);
return -EINVAL;
}
for (i = 0; i < size; i += 8) {
tmp = 0;
bits = 63;
for (j = 0; j < 7; j++) {
dc = (*src & 0x0100) ? 1 : 0;
val = *src & 0x00FF;
tmp |= dc << bits;
bits -= 8;
tmp |= val << bits--;
src++;
}
tmp |= ((*src & 0x0100) ? 1 : 0);
*(__be64 *)dst = cpu_to_be64(tmp);
dst += 8;
*dst++ = (u8)(*src++ & 0x00FF);
added++;
}
return spi_write(par->spi, par->extra, size + added);
}
int fbtft_read_spi(struct fbtft_par *par, void *buf, size_t len)
{
int ret;
u8 txbuf[32] = { 0, };
struct spi_transfer t = {
.speed_hz = 2000000,
.rx_buf = buf,
.len = len,
};
struct spi_message m;
if (!par->spi) {
dev_err(par->info->device,
"%s: par->spi is unexpectedly NULL\n", __func__);
return -ENODEV;
}
if (par->startbyte) {
if (len > 32) {
dev_err(par->info->device,
"len=%zu can't be larger than 32 when using 'startbyte'\n",
len);
return -EINVAL;
}
txbuf[0] = par->startbyte | 0x3;
t.tx_buf = txbuf;
fbtft_par_dbg_hex(DEBUG_READ, par, par->info->device, u8,
txbuf, len, "%s(len=%zu) txbuf => ",
__func__, len);
}
spi_message_init(&m);
spi_message_add_tail(&t, &m);
ret = spi_sync(par->spi, &m);
fbtft_par_dbg_hex(DEBUG_READ, par, par->info->device, u8, buf, len,
"%s(len=%zu) buf <= ", __func__, len);
return ret;
}
/*
* Optimized use of gpiolib is twice as fast as no optimization
* only one driver can use the optimized version at a time
*/
int fbtft_write_gpio8_wr(struct fbtft_par *par, void *buf, size_t len)
{
u8 data;
int i;
#ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
static u8 prev_data;
#endif
fbtft_par_dbg_hex(DEBUG_WRITE, par, par->info->device, u8, buf, len,
"%s(len=%zu): ", __func__, len);
while (len--) {
data = *(u8 *)buf;
/* Start writing by pulling down /WR */
gpiod_set_value(par->gpio.wr, 1);
/* Set data */
#ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
if (data == prev_data) {
gpiod_set_value(par->gpio.wr, 1); /* used as delay */
} else {
for (i = 0; i < 8; i++) {
if ((data & 1) != (prev_data & 1))
gpiod_set_value(par->gpio.db[i],
data & 1);
data >>= 1;
prev_data >>= 1;
}
}
#else
for (i = 0; i < 8; i++) {
gpiod_set_value(par->gpio.db[i], data & 1);
data >>= 1;
}
#endif
/* Pullup /WR */
gpiod_set_value(par->gpio.wr, 0);
#ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
prev_data = *(u8 *)buf;
#endif
buf++;
}
return 0;
}
int fbtft_write_gpio16_wr(struct fbtft_par *par, void *buf, size_t len)
{
u16 data;
int i;
#ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
static u16 prev_data;
#endif
fbtft_par_dbg_hex(DEBUG_WRITE, par, par->info->device, u8, buf, len,
"%s(len=%zu): ", __func__, len);
while (len) {
data = *(u16 *)buf;
/* Start writing by pulling down /WR */
gpiod_set_value(par->gpio.wr, 1);
/* Set data */
#ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
if (data == prev_data) {
gpiod_set_value(par->gpio.wr, 1); /* used as delay */
} else {
for (i = 0; i < 16; i++) {
if ((data & 1) != (prev_data & 1))
gpiod_set_value(par->gpio.db[i],
data & 1);
data >>= 1;
prev_data >>= 1;
}
}
#else
for (i = 0; i < 16; i++) {
gpiod_set_value(par->gpio.db[i], data & 1);
data >>= 1;
}
#endif
/* Pullup /WR */
gpiod_set_value(par->gpio.wr, 0);
#ifndef DO_NOT_OPTIMIZE_FBTFT_WRITE_GPIO
prev_data = *(u16 *)buf;
#endif
buf += 2;
len -= 2;
}
return 0;
}
int fbtft_write_gpio16_wr_latched(struct fbtft_par *par, void *buf, size_t len)
{
dev_err(par->info->device, "%s: function not implemented\n", __func__);
return -1;
}
/*************************************************************fbtft-io.c文件的结束***************************************************************/
/***********************************************************st7789v主文件得主要内容**************************************************************/
#define WIDTH 320
#define HEIGHT 480
/* this init sequence matches PiScreen */
//这个是一维数组，以负数为标志位，告诉下面的函数读取时读的是什么
static const s16 default_init_sequence[] = {
/* Interface Mode Control */ //设置spi传输数据的模式
-1, 0xb0, 0x0,
-1, MIPI_DCS_EXIT_SLEEP_MODE, //退出睡眠模式
-2, 250,
/* Interface Pixel Format */ //设置spi像素格式
-1, MIPI_DCS_SET_PIXEL_FORMAT, 0x55,
/* Power Control 3 */ //功率控制
-1, 0xC2, 0x44, //电源模式，正常模式
-1, 0x21, //反显
/* VCOM Control 1 */ //vcom控制
-1, 0xC5, 0x00, 0x00, 0x00, 0x00,
//-1, 0xC5, 0x00, 0x1e, 0x80,
//-1, 0xb1, 0xb0,//设置全彩模式下的帧率
-1, 0xb6, 0x02,0x42,
-1, 0x36, 0x28,
/* PGAMCTRL(Positive Gamma Control) */
-1, 0xE0, 0x00, 0x13, 0x18, 0x04, 0x0F, 0x06, 0x3a, 0x56,
0x4d, 0x03, 0x0a, 0x06, 0x30, 0x3e, 0x0f,
// -1, 0xE0, 0x00, 0x07, 0x10, 0x09, 0x17, 0x0b, 0x41, 0x89,
// 0x4b, 0x0a, 0x0c, 0x0e, 0x18, 0x1b, 0x0f,
/* NGAMCTRL(Negative Gamma Control) */
-1, 0xE1, 0x00, 0x13, 0x18, 0x01, 0x11, 0x06, 0x38, 0x34,
0x4d, 0x06, 0x0d, 0x0b, 0x31, 0x37, 0x0f,
// -1, 0xE1, 0x00, 0x17, 0x1a, 0x04, 0x0e, 0x06, 0x2f, 0x45,
// 0x43, 0x02, 0x0a, 0x09, 0x32, 0x36, 0x0f,
-1, MIPI_DCS_EXIT_SLEEP_MODE,
-1, MIPI_DCS_SET_DISPLAY_ON,
/* end marker */
-3
};
static void set_addr_win(struct fbtft_par *par, int xs, int ys, int xe, int ye)
{
write_reg(par, MIPI_DCS_SET_COLUMN_ADDRESS,
xs >> 8, xs & 0xFF, xe >> 8, xe & 0xFF);
write_reg(par, MIPI_DCS_SET_PAGE_ADDRESS,
ys >> 8, ys & 0xFF, ye >> 8, ye & 0xFF);
write_reg(par, MIPI_DCS_WRITE_MEMORY_START);
}
static int set_var(struct fbtft_par *par)
{
switch (par->info->var.rotate) {
case 0:
write_reg(par, MIPI_DCS_SET_ADDRESS_MODE,
0x80 | (par->bgr << 3));
printk("进入设置角度的函数\n");
break;
case 90:
write_reg(par, MIPI_DCS_SET_ADDRESS_MODE,
0x20 | (par->bgr << 3));
break;
case 180:
write_reg(par, MIPI_DCS_SET_ADDRESS_MODE,
0x40 | (par->bgr << 3));
break;
case 270:
write_reg(par, MIPI_DCS_SET_ADDRESS_MODE,
0xE0 | (par->bgr << 3));
break;
default:
break;
}
return 0;
}
static struct fbtft_display display = {
.regwidth = 8,
.width = WIDTH,
.height = HEIGHT,
.init_sequence = default_init_sequence,
.fbtftops = {
.set_addr_win = set_addr_win,
.set_var = set_var,
},
};
FBTFT_REGISTER_DRIVER(DRVNAME, "ilitek,ili9488", &display);//匹配设备树的宏
/*********************************************************st7789v主文件的内容结束************************************************************************************/
/**************************************************匹配设备函数入口**********************************************************************************/
/****************************prob和remove得具体实现**********************************************/
/**
* fbtft_probe_common() - Generic device probe() helper function
* @display: Display properties
* @sdev: SPI device
* @pdev: Platform device
*
* Allocates, initializes and registers a framebuffer
*
* Either @sdev or @pdev should be NULL
*
* Return: 0 if successful, negative if error
*/
//prob入口初始化实际函数实现
int fbtft_probe_common(struct fbtft_display *display,
struct spi_device *sdev,
struct platform_device *pdev)
{
struct device *dev;
struct fb_info *info;
struct fbtft_par *par;
struct fbtft_platform_data *pdata;
int ret;
//判断是spi设备还是平台设备驱动
if (sdev)
dev = &sdev->dev;
else
dev = &pdev->dev;
if (unlikely(display->debug & DEBUG_DRIVER_INIT_FUNCTIONS)) //define DEBUG_DRIVER_INIT_FUNCTIONS BIT(3)，意思是将1左移3位
dev_info(dev, "%s()\n", __func__);
pdata = dev->platform_data;//特定的显示数据的结构体
if (!pdata) {
pdata = fbtft_properties_read(dev);
if (IS_ERR(pdata))
return PTR_ERR(pdata);
}
info = fbtft_framebuffer_alloc(display, dev, pdata); //创建一个新的帧缓冲区信息结构，分配空间等操作
if (!info)
return -ENOMEM;
par = info->par;
par->spi = sdev;
par->pdev = pdev;
if (display->buswidth == 0) {
dev_err(dev, "buswidth is not set\n");
return -EINVAL;
}
/* write register functions */ //写寄存器函数，写数据或命令的函数
if (display->regwidth == 8 && display->buswidth == 8)
par->fbtftops.write_register = fbtft_write_reg8_bus8;
else if (display->regwidth == 8 && display->buswidth == 9 && par->spi)
par->fbtftops.write_register = fbtft_write_reg8_bus9;
else if (display->regwidth == 16 && display->buswidth == 8)
par->fbtftops.write_register = fbtft_write_reg16_bus8;
else if (display->regwidth == 16 && display->buswidth == 16)
par->fbtftops.write_register = fbtft_write_reg16_bus16;
else
dev_warn(dev,
"no default functions for regwidth=%d and buswidth=%d\n",
display->regwidth, display->buswidth);
/* write_vmem() functions */ //写显存到显示器
if (display->buswidth == 8)
par->fbtftops.write_vmem = fbtft_write_vmem16_bus8;
else if (display->buswidth == 9)
par->fbtftops.write_vmem = fbtft_write_vmem16_bus9;
else if (display->buswidth == 16)
par->fbtftops.write_vmem = fbtft_write_vmem16_bus16;
/* GPIO write() functions */ //gpio写函数
if (par->pdev) {
if (display->buswidth == 8)
par->fbtftops.write = fbtft_write_gpio8_wr;
else if (display->buswidth == 16)
par->fbtftops.write = fbtft_write_gpio16_wr;
}
/* 9-bit SPI setup */ //spi 9bit函数的启动
if (par->spi && display->buswidth == 9) {
if (par->spi->master->bits_per_word_mask & SPI_BPW_MASK(9)) {
par->spi->bits_per_word = 9;
} else {
dev_warn(&par->spi->dev,
"9-bit SPI not available, emulating using 8-bit.\n");
/* allocate buffer with room for dc bits */
par->extra = devm_kzalloc(par->info->device,
par->txbuf.len +
(par->txbuf.len / 8) + 8,
GFP_KERNEL);
if (!par->extra) {
ret = -ENOMEM;
goto out_release;
}
par->fbtftops.write = fbtft_write_spi_emulate_9;
}
}
if (!par->fbtftops.verify_gpios)
par->fbtftops.verify_gpios = fbtft_verify_gpios;
/* make sure we still use the driver provided functions */ //确保我们仍然使用驱动程序提供的函数
fbtft_merge_fbtftops(&par->fbtftops, &display->fbtftops);
/* use init_sequence if provided */ //如果提供的话，使用init sequence
if (par->init_sequence)
par->fbtftops.init_display = fbtft_init_display;
/* use platform_data provided functions above all */ //首先使用platform_data提供的函数
fbtft_merge_fbtftops(&par->fbtftops, &pdata->display.fbtftops);
ret = fbtft_register_framebuffer(info);
if (ret < 0)
goto out_release;
return 0;
out_release:
fbtft_framebuffer_release(info);
return ret;
}
/**
* fbtft_remove_common() - Generic device remove() helper function
* @dev: Device
* @info: Framebuffer
*
* Unregisters and releases the framebuffer
*
* Return: 0 if successful, negative if error
*/
//出口函数实际实现
int fbtft_remove_common(struct device *dev, struct fb_info *info)
{
struct fbtft_par *par;
if (!info)
return -EINVAL;
par = info->par;
if (par)
fbtft_par_dbg(DEBUG_DRIVER_INIT_FUNCTIONS, par,
"%s()\n", __func__);
fbtft_unregister_framebuffer(info);
fbtft_framebuffer_release(info);
return 0;
}
/*********************prob和remove得具体实现结束****************************************/
/*****************************设备树匹配模块*********************************************************/
//这部分代码被宏代替，所以注释
/**************************设备树匹配模块结束*******************************************/
// module_init(fbtft_driver_module_init); //入口宏
// module_exit(fbtft_driver_module_exit); //出口宏
/**************************************************匹配设备完成**************************************************************************************/
MODULE_ALIAS("spi:" DRVNAME);
MODULE_ALIAS("platform:" DRVNAME);
MODULE_ALIAS("spi:ili9488");
MODULE_ALIAS("platform:ili9488");
MODULE_DESCRIPTION("FB driver for the ili9488 LCD Controller");
MODULE_AUTHOR("Dennis Menschel");
MODULE_LICENSE("GPL");
4 设备树
4.1 关闭设备节点
设备树也是一个坎，其他部分内容在网上都有参考依据，代码调试调试都能改出来。但下面这个关闭spidev节点是真的想不到，这个东西如果官方不放出来的话，很难自己搞出来；因为根本就和设备树不搭边啊！设置各种属性是知道的，但单独关闭一个spi的节点，这是怎么能想到的呢？
spidev@0 {
status = "disabled";
};此外，如果还是点亮不成功，可以考虑在设备树里加一下这个参数，用于调整spi得时钟相位和时钟极性。这个参数是我在开发板群里向其他大佬请教时获取得一组参数，适用的屏幕应该是st7789v芯片屏幕，具体情况还是要看开发手册。
spi-cpol;
spi-cpha;4.2 设备树编写
看了半天感觉设备树没啥讲的，就是初始化几个节点，具体配置如下：
&spi0 {
status = "okay";
pinctrl-names = "default";
pinctrl-0 = <&spi0m0_pins &tp_irq>;
// cs-gpios = <&gpio1 RK_PC0 1>;
// cs-gpios = <&gpio1 26 1>;
#address-cells = <1>;
#size-cells = <0>;
spidev@0 {
status = "disabled";
};
ili9488@0{
status = "okay";
compatible = "ilitek,ili9488";
reg = <0>;
spi-max-frequency = <20000000>;
fps = <30>;
bpp = <24>;
buswidth = <8>;
debug = <0x7>;
led-gpios = <&gpio0 RK_PA4 GPIO_ACTIVE_LOW>;//BL
dc = <&gpio1 RK_PA2 GPIO_ACTIVE_HIGH>; //DC
reset = <&gpio1 RK_PD1 GPIO_ACTIVE_LOW>; //RES-ili9488
// reset = <&gpio1 RK_PC3 GPIO_ACTIVE_LOW>; //RES-st7789v
};
};
&pinctrl {
spi0 {
/omit-if-no-ref/
spi0m0_pins: spi0m0-pins {
rockchip,pins =
/* spi0_clk_m0 */
<1 RK_PC1 4 &pcfg_pull_none>,
/* spie_miso_m0 */
<1 RK_PC3 6 &pcfg_pull_none>,
/* spi_mosi_m0 */
<1 RK_PC2 6 &pcfg_pull_none>;
};
};
};注：还有一部分引脚初始化的代码我就不放了，都是千篇一律的东西，想了解的看上面spi章节的截图，自己照葫芦画瓢修改就行了。
4.3 小结
至此，我们可以看出frammebuffer驱动核心内容也就三大模块，frammmebuffer子系统、spi子系统、颜色配置，搞懂这三大块剩余部分都是细枝末节，慢慢读都可以看懂。其实很想吐槽得一点就是，官方为了兼容性，把驱动写得过于全面和复杂，我为了方便读代码，专门把官方的驱动整合到了一个.c文件中，整理过程中发现很多函数和代码压根就没被调用，精简完以后，代码少了很大一块。
5 drm的简介
我因为屏幕限制，没搞drm这么高级的驱动，就查询整理了一些资料分享给大家。
DRM（Direct Rendering Manager）驱动和Framebuffer驱动是Linux操作系统中用于管理图形硬件的两种不同的图形子系统，它们在架构和功能上存在显著的差异。
5.1 设计目标
Framebuffer 驱动：
最初设计用于简单的图形输出设备。
目标是提供基本的、直接的帧缓冲访问接口，允许用户空间应用程序直接写入显存，绘制图像。
它不支持现代图形硬件的高级特性，比如硬件加速、显示管道管理、VSync、双缓冲等。
适用于简单的嵌入式系统和终端设备，性能需求较低。DRM 驱动：
设计目标是支持现代 GPU 和复杂的图形硬件，主要用于桌面系统、图形界面和需要硬件加速的应用程序（例如游戏、图形密集型应用）。
支持硬件加速、渲染、多显示器、双缓冲等高级功能。
DRM 驱动与 KMS（Kernel Mode Setting，内核模式设置）紧密结合，允许内核控制显示模式、连接器等显示资源管理。5.2 架构
Framebuffer 驱动：
简单的架构，核心是通过 /dev/fb0 等设备节点与显存直接交互。
通过 mmap 映射显存，用户空间应用可以直接操作显存中的每个像素。
没有 GPU 硬件加速支持，也不处理复杂的显示任务。
显示的分辨率和颜色深度等设置在驱动加载时完成，无法动态切换。DRM 驱动：
DRM 驱动是 Linux 内核中的一个子系统，包含两个主要部分：渲染和显示。
DRM 通过与 GPU 硬件的交互，实现硬件加速渲染，同时管理显示输出。
KMS 是 DRM 的一部分，用于管理显示管道，设置显示模式（如分辨率、刷新率）等。
DRM 驱动通过与用户空间图形栈（如 Mesa、Xorg 或 Wayland）协作，提供复杂的图形操作和渲染支持。
支持多缓冲（如双缓冲、三缓冲）和 VSync，以确保平滑的图像更新。5.3 功能和性能
Framebuffer 驱动：
功能简单，适合直接访问显存进行像素级别的绘制操作。
不支持硬件加速，所有的图形操作（如图形绘制、窗口管理等）都依赖于 CPU，这对于复杂的图形应用程序性能较差。
不具备多显示器管理、硬件加速渲染等功能。
典型使用场景：嵌入式系统中的控制台、简单图形应用。DRM 驱动：
支持 GPU 加速，可以使用 GPU 来执行复杂的图形计算任务，如 3D 渲染、图像处理等。
具备多显示器支持，可以通过内核动态调整显示器的分辨率、刷新率、颜色格式等。
通过 VSync 同步，防止图像撕裂，支持更高的帧率和显示效果。
典型使用场景：桌面环境、游戏、3D 图形应用等。5.4 用户空间接口
Framebuffer 驱动：
提供简单的用户空间接口 /dev/fbX，可以通过文件读写和 ioctl 调用与驱动进行交互。
主要用于绘制像素数据，但不支持复杂的 3D 渲染。DRM 驱动：
通过 /dev/dri/cardX 提供接口，允许用户空间通过 DRM IOCTL 与 GPU 驱动进行交互。
支持用户空间的图形库，如 Mesa3D、X11、Wayland、EGL 等。
现代图形栈（如 Xorg、Wayland）都依赖 DRM 驱动来提供硬件加速支持。5.5 显示管理
Framebuffer 驱动：
依赖于固定分辨率的模式设置，难以动态调整显示输出。
缺乏多显示器支持，不能同时管理多个显示设备。DRM 驱动：
通过 KMS 可以动态设置和管理显示模式，如分辨率、刷新率等。
具备多显示器支持，能够管理多个显示输出（如 HDMI、DisplayPort、VGA 等）。5.6 使用场景
Framebuffer 驱动：
简单图形输出，不需要 GPU 加速的应用。
主要用于嵌入式设备或不需要复杂图形操作的系统。
终端控制台、早期的 Linux 系统控制台、一些嵌入式系统。DRM 驱动：
桌面系统（如 GNOME、KDE）使用 DRM 驱动来提供图形加速。
游戏、视频播放和需要高性能渲染的应用程序都依赖于 DRM 驱动。
现代桌面系统的显示服务器（如 Wayland、Xorg）通过 DRM 驱动来控制显示输出和渲染操作。5.7 小结
Framebuffer 是一种老旧的显示管理方式，主要提供直接的显存访问，不支持硬件加速，功能较为简单。
DRM 则是现代 Linux 图形栈的重要部分，支持 GPU 硬件加速和复杂的显示管理，是当前桌面系统和图形应用的核心组件。
6 总结
至此，lcd屏幕的显示部分驱动就移植完成了，这个文章的着重点其实就是我在移植屏幕时遇到的问题。整体移植完成回来看时，我觉得framebuffer子系统没啥太难的部分；都是因为不熟悉驱动框架，才导致我不断的踏进各种坑里又不断地爬出来。值得庆幸的是最终我完成了驱动地移植工作。
最后，这个是我个人在移植屏幕时遇到地问题，如何阅读文章地各位遇到其他问题欢迎评论区一起讨论！！！！