Serial RGB 点亮 854x480 屏

注意芯片型号！

首先确认芯片型号是否为支持型号。

V821 视频输出规格如下：

• Serial RGB interface,up to 800x480@60fps
• Serial 8-bit i8080 interface, up to 800x480@60fps
• Dither function for RGB888, RGB666 and RGB565
• Support BT.656 interface for NTSC and PAL
• Supports Fsync(Frame Synchronization) for camera sensor

这次点的屏幕是基于 NV3049F 驱动 IC 的 854x480 Serial RGB 屏。屏幕型号为 F450003

提示

串行RGB是相对于并行RGB来说，而并不是说它只用一根线来发数据，只要通过多个时钟周期才能把一个像素的数据发完，那么这样的RGB接口就是串行RGB。也叫做 8 位 RGB 屏。

Serial RGB 时序如下：

引脚配置如下：

V821	引脚复用功能	TFT 模块
PD1—PD8	LCD-D3—LCD-D12	D0—D7
PD12	LCD-VSYNC	VSYNC
PD11	LCD-HSYNC	HSYNC
PD9	LCD-CLK	CLK
PD10	LCD-DE	DE
PD14	GPIO OUTPUT（3 线 SPI 初始化使用）	CS
PD15	GPIO OUTPUT（3 线 SPI 初始化使用）	SCK
PD16	GPIO OUTPUT（3 线 SPI 初始化使用）	SDA
PD17	GPIO OUTPUT（3 线 SPI 初始化使用）	RESET

编写 LCD 显示屏驱动

准备驱动框架

前往屏幕驱动路径：bsp/drivers/video/sunxi/disp2/disp/lcd/ 下，将

• bsp/drivers/video/sunxi/disp2/disp/lcd/default_panel.c
• bsp/drivers/video/sunxi/disp2/disp/lcd/default_panel.h

复制一份作为模板

然后改名为此款屏幕的驱动：

打开 bsp/drivers/video/sunxi/disp2/disp/lcd/f450003.c 文件，将 default_panel 改为 f450003

同时修改 name，为屏幕实际名称

头文件也一并修改

获取屏幕初始化序列

首先询问屏厂提供初始化序列，和屏幕手册。

屏厂会提供一个初始化代码：

////////////////NV3049F+BOE4.5////////////////////

Write_LCD_REG_CMD(0xFF);
Write_LCD_REG_DATA(0x30);
Write_LCD_REG_CMD(0xFF);
Write_LCD_REG_DATA(0x49);
Write_LCD_REG_CMD(0xFF);
Write_LCD_REG_DATA(0x01);
Write_LCD_REG_CMD(0xe2);
Write_LCD_REG_DATA(0x00);

Write_LCD_REG_CMD(0xe2);
Write_LCD_REG_DATA(0x00);
//Write_LCD_REG_CMD(0xF1);
//Write_LCD_REG_DATA(0x0e);//bist

Write_LCD_REG_CMD(0x14);
Write_LCD_REG_DATA(0x08);//vbp_para[7:0]
Write_LCD_REG_CMD(0x11);
Write_LCD_REG_DATA(0x08);//vfp_para[7:0]
Write_LCD_REG_CMD(0x16);
Write_LCD_REG_DATA(0x14);//hfp
Write_LCD_REG_CMD(0x19);
Write_LCD_REG_DATA(0x19);//hbp

Write_LCD_REG_CMD(0x15);//vbp_seri[7:0]
Write_LCD_REG_DATA(0x08);
Write_LCD_REG_CMD(0x12);//vfp_seri[7:0]
Write_LCD_REG_DATA(0x08);
Write_LCD_REG_CMD(0x17);//hfp_seri
Write_LCD_REG_DATA(0x14);
Write_LCD_REG_CMD(0x1A);//hbp_seri
Write_LCD_REG_DATA(0x19);

Write_LCD_REG_CMD(0x20);
Write_LCD_REG_DATA(0x5c);
Write_LCD_REG_CMD(0x21);
Write_LCD_REG_DATA(0x02);//20241227
Write_LCD_REG_CMD(0x3b);
Write_LCD_REG_DATA(0x04);//LVD
Write_LCD_REG_CMD(0x41);
Write_LCD_REG_DATA(0x32);
Write_LCD_REG_CMD(0x45);
Write_LCD_REG_DATA(0x03);
Write_LCD_REG_CMD(0x46);
Write_LCD_REG_DATA(0x55);

//////////////SOURCE/////////////////
Write_LCD_REG_CMD(0x51);
Write_LCD_REG_DATA(0x36);
Write_LCD_REG_CMD(0x52);
Write_LCD_REG_DATA(0x01);

Write_LCD_REG_CMD(0x53);
Write_LCD_REG_DATA(0x20);
Write_LCD_REG_CMD(0x54);
Write_LCD_REG_DATA(0x12);
Write_LCD_REG_CMD(0x55);
Write_LCD_REG_DATA(0x01);

Write_LCD_REG_CMD(0x56);
Write_LCD_REG_DATA(0x03);

Write_LCD_REG_CMD(0x57);
Write_LCD_REG_DATA(0x37);

//Write_LCD_REG_CMD(0x59);
//Write_LCD_REG_DATA(0x00);
//Write_LCD_REG_CMD(0x5A);
//Write_LCD_REG_DATA(0x00);

Write_LCD_REG_CMD(0x5B);
Write_LCD_REG_DATA(0x82);
Write_LCD_REG_CMD(0x5C);
Write_LCD_REG_DATA(0x10);
Write_LCD_REG_CMD(0x5D);
Write_LCD_REG_DATA(0x80);//

Write_LCD_REG_CMD(0x79);
Write_LCD_REG_DATA(0xFE);
Write_LCD_REG_CMD(0x7D);
Write_LCD_REG_DATA(0x08);

//////////////SOURCE/////////////////


Write_LCD_REG_CMD(0x90);
Write_LCD_REG_DATA(0x00);//VSP
Write_LCD_REG_CMD(0x91);
Write_LCD_REG_DATA(0x00);//VSN

Write_LCD_REG_CMD(0x95);
Write_LCD_REG_DATA(0x0c);

Write_LCD_REG_CMD(0x94);
Write_LCD_REG_DATA(0x08);
Write_LCD_REG_CMD(0x96);
Write_LCD_REG_DATA(0x16);

Write_LCD_REG_CMD(0x98);
Write_LCD_REG_DATA(0x33);

Write_LCD_REG_CMD(0xca);
Write_LCD_REG_DATA(0x14);  
Write_LCD_REG_CMD(0xc8);
Write_LCD_REG_DATA(0x6e); 
Write_LCD_REG_CMD(0xcc);
Write_LCD_REG_DATA(0x12); 
Write_LCD_REG_CMD(0xe7);
Write_LCD_REG_DATA(0x30);
Write_LCD_REG_CMD(0xA0);
Write_LCD_REG_DATA(0x30);
Write_LCD_REG_CMD(0xB4);
Write_LCD_REG_DATA(0x30);
Write_LCD_REG_CMD(0xA1);
Write_LCD_REG_DATA(0x22);
Write_LCD_REG_CMD(0xB5);
Write_LCD_REG_DATA(0x21);
Write_LCD_REG_CMD(0xA2);
Write_LCD_REG_DATA(0x20);
Write_LCD_REG_CMD(0xB6);
Write_LCD_REG_DATA(0x1E);
Write_LCD_REG_CMD(0xA5);
Write_LCD_REG_DATA(0x0F);
Write_LCD_REG_CMD(0xB9);
Write_LCD_REG_DATA(0x11);
Write_LCD_REG_CMD(0xA6);
Write_LCD_REG_DATA(0x08);
Write_LCD_REG_CMD(0xBA);
Write_LCD_REG_DATA(0x07);
Write_LCD_REG_CMD(0xA7);
Write_LCD_REG_DATA(0x08);
Write_LCD_REG_CMD(0xBB);
Write_LCD_REG_DATA(0x08);
Write_LCD_REG_CMD(0xA3);
Write_LCD_REG_DATA(0x40);
Write_LCD_REG_CMD(0xB7);
Write_LCD_REG_DATA(0x42);
Write_LCD_REG_CMD(0xA4);
Write_LCD_REG_DATA(0x40);
Write_LCD_REG_CMD(0xB8);
Write_LCD_REG_DATA(0x42);
Write_LCD_REG_CMD(0xA8);
Write_LCD_REG_DATA(0x0F);
Write_LCD_REG_CMD(0xBC);
Write_LCD_REG_DATA(0x0E);
Write_LCD_REG_CMD(0xA9);
Write_LCD_REG_DATA(0x15);
Write_LCD_REG_CMD(0xBD);
Write_LCD_REG_DATA(0x14);
Write_LCD_REG_CMD(0xAA);
Write_LCD_REG_DATA(0x15);
Write_LCD_REG_CMD(0xBE);
Write_LCD_REG_DATA(0x15);
Write_LCD_REG_CMD(0xAB);
Write_LCD_REG_DATA(0x15);
Write_LCD_REG_CMD(0xBF);
Write_LCD_REG_DATA(0x14);
Write_LCD_REG_CMD(0xAC);
Write_LCD_REG_DATA(0x10);
Write_LCD_REG_CMD(0xC0);
Write_LCD_REG_DATA(0x10);
Write_LCD_REG_CMD(0xAD);
Write_LCD_REG_DATA(0x11);
Write_LCD_REG_CMD(0xC1);
Write_LCD_REG_DATA(0x12);
Write_LCD_REG_CMD(0xAE);
Write_LCD_REG_DATA(0x10);
Write_LCD_REG_CMD(0xC2);
Write_LCD_REG_DATA(0x13);
Write_LCD_REG_CMD(0xAF);
Write_LCD_REG_DATA(0x0f);
Write_LCD_REG_CMD(0xC3);
Write_LCD_REG_DATA(0x12);
Write_LCD_REG_CMD(0xB0);
Write_LCD_REG_DATA(0x10);
Write_LCD_REG_CMD(0xC4);
Write_LCD_REG_DATA(0x10);
Write_LCD_REG_CMD(0xB1);
Write_LCD_REG_DATA(0x08);
Write_LCD_REG_CMD(0xC5);
Write_LCD_REG_DATA(0x0A);

Write_LCD_REG_CMD(0xFF);
Write_LCD_REG_DATA(0x30);
Write_LCD_REG_CMD(0xFF);
Write_LCD_REG_DATA(0x49);
Write_LCD_REG_CMD(0xFF);
Write_LCD_REG_DATA(0x03);

///////////////////////////GOA//////////////////////////////
Write_LCD_REG_CMD(0x27);
Write_LCD_REG_DATA(0x88);
Write_LCD_REG_CMD(0x28);
Write_LCD_REG_DATA(0x06);
Write_LCD_REG_CMD(0x29);
Write_LCD_REG_DATA(0x04);

Write_LCD_REG_CMD(0x36);
Write_LCD_REG_DATA(0x88);
Write_LCD_REG_CMD(0x37);
Write_LCD_REG_DATA(0x05);
Write_LCD_REG_CMD(0x38);
Write_LCD_REG_DATA(0x03);

Write_LCD_REG_CMD(0x2a);
Write_LCD_REG_DATA(0x11);
Write_LCD_REG_CMD(0x2b);
Write_LCD_REG_DATA(0x60);
Write_LCD_REG_CMD(0x2c);
Write_LCD_REG_DATA(0x80);

Write_LCD_REG_CMD(0x79);
Write_LCD_REG_DATA(0x3f);
Write_LCD_REG_CMD(0x7a);
Write_LCD_REG_DATA(0x3f);

Write_LCD_REG_CMD(0x7B);
Write_LCD_REG_DATA(0x30);

Write_LCD_REG_CMD(0x80);
Write_LCD_REG_DATA(0x85);
Write_LCD_REG_CMD(0x81);
Write_LCD_REG_DATA(0x13);
Write_LCD_REG_CMD(0x82);
Write_LCD_REG_DATA(0x5a);
Write_LCD_REG_CMD(0x83);
Write_LCD_REG_DATA(0x05);
Write_LCD_REG_CMD(0x84);
Write_LCD_REG_DATA(0x60);
Write_LCD_REG_CMD(0x85);
Write_LCD_REG_DATA(0x80);


Write_LCD_REG_CMD(0x88);
Write_LCD_REG_DATA(0x84);
Write_LCD_REG_CMD(0x89);
Write_LCD_REG_DATA(0x13);
Write_LCD_REG_CMD(0x8A);
Write_LCD_REG_DATA(0x5b);
Write_LCD_REG_CMD(0x8B);
Write_LCD_REG_DATA(0x11);
Write_LCD_REG_CMD(0x8C);
Write_LCD_REG_DATA(0x60);
Write_LCD_REG_CMD(0x8D);
Write_LCD_REG_DATA(0x80);


Write_LCD_REG_CMD(0x8E);
Write_LCD_REG_DATA(0x83);
Write_LCD_REG_CMD(0x8F);
Write_LCD_REG_DATA(0x13);
Write_LCD_REG_CMD(0x90);
Write_LCD_REG_DATA(0x5c);
Write_LCD_REG_CMD(0x91);
Write_LCD_REG_DATA(0x11);
Write_LCD_REG_CMD(0x92);
Write_LCD_REG_DATA(0x60);
Write_LCD_REG_CMD(0x93);
Write_LCD_REG_DATA(0x80);


Write_LCD_REG_CMD(0x94);
Write_LCD_REG_DATA(0x82);
Write_LCD_REG_CMD(0x95);
Write_LCD_REG_DATA(0x13);
Write_LCD_REG_CMD(0x96);
Write_LCD_REG_DATA(0x5d);
Write_LCD_REG_CMD(0x97);
Write_LCD_REG_DATA(0x11);
Write_LCD_REG_CMD(0x98);
Write_LCD_REG_DATA(0x60);
Write_LCD_REG_CMD(0x99);
Write_LCD_REG_DATA(0x80);
///////////////////////////GOA//////////////////////////////

/////////////////////////GOA MAP//////////////////////

Write_LCD_REG_CMD(0xD0);
Write_LCD_REG_DATA(0x1F);
Write_LCD_REG_CMD(0xD1);
Write_LCD_REG_DATA(0x1A);
Write_LCD_REG_CMD(0xD2);
Write_LCD_REG_DATA(0x0A);
Write_LCD_REG_CMD(0xD3);
Write_LCD_REG_DATA(0x0C);
Write_LCD_REG_CMD(0xD4);
Write_LCD_REG_DATA(0x04);
Write_LCD_REG_CMD(0xD5);
Write_LCD_REG_DATA(0x1B);
Write_LCD_REG_CMD(0xD6);
Write_LCD_REG_DATA(0x1F);
Write_LCD_REG_CMD(0xD7);
Write_LCD_REG_DATA(0x1F);
Write_LCD_REG_CMD(0xD8);
Write_LCD_REG_DATA(0x1F);
Write_LCD_REG_CMD(0xD9);
Write_LCD_REG_DATA(0x1F);
Write_LCD_REG_CMD(0xDA);
Write_LCD_REG_DATA(0x1f);
Write_LCD_REG_CMD(0xDB);
Write_LCD_REG_DATA(0x1f);
Write_LCD_REG_CMD(0xDC);
Write_LCD_REG_DATA(0x1F);
Write_LCD_REG_CMD(0xDD);
Write_LCD_REG_DATA(0x1F);
Write_LCD_REG_CMD(0xDE);
Write_LCD_REG_DATA(0x1F);
Write_LCD_REG_CMD(0xDF);
Write_LCD_REG_DATA(0x1F);

Write_LCD_REG_CMD(0xE0);
Write_LCD_REG_DATA(0x1F);
Write_LCD_REG_CMD(0xE1);
Write_LCD_REG_DATA(0x1F);
Write_LCD_REG_CMD(0xE2);
Write_LCD_REG_DATA(0x1f);
Write_LCD_REG_CMD(0xE3);
Write_LCD_REG_DATA(0x1f);
Write_LCD_REG_CMD(0xE4);
Write_LCD_REG_DATA(0x1f);
Write_LCD_REG_CMD(0xE5);
Write_LCD_REG_DATA(0x1f);
Write_LCD_REG_CMD(0xE6);
Write_LCD_REG_DATA(0x1F);
Write_LCD_REG_CMD(0xE7);
Write_LCD_REG_DATA(0x1F);
Write_LCD_REG_CMD(0xE8);
Write_LCD_REG_DATA(0x1F);
Write_LCD_REG_CMD(0xE9);
Write_LCD_REG_DATA(0x1F);
Write_LCD_REG_CMD(0xEA);
Write_LCD_REG_DATA(0x1B);
Write_LCD_REG_CMD(0xEB);
Write_LCD_REG_DATA(0x05);
Write_LCD_REG_CMD(0xEC);
Write_LCD_REG_DATA(0x0D);
Write_LCD_REG_CMD(0xED);
Write_LCD_REG_DATA(0x0B);
Write_LCD_REG_CMD(0xEE);
Write_LCD_REG_DATA(0x1A);
Write_LCD_REG_CMD(0xEF);
Write_LCD_REG_DATA(0x1F);

/////////////////////////GOA MAP//////////////////////
//Write_LCD_REG_CMD(0xf7);
//Write_LCD_REG_DATA(0x20);
//Write_LCD_REG_CMD(0xf8);
//Write_LCD_REG_DATA(0x20);

//HL Temp test
Write_LCD_REG_CMD(0xf7);
Write_LCD_REG_DATA(0x50);
Write_LCD_REG_CMD(0xf8);
Write_LCD_REG_DATA(0x50);

Write_LCD_REG_CMD(0xFF);
Write_LCD_REG_DATA(0x30);
Write_LCD_REG_CMD(0xFF);
Write_LCD_REG_DATA(0x49);
Write_LCD_REG_CMD(0xFF);
Write_LCD_REG_DATA(0x00);
Write_LCD_REG_CMD(0xF1);
Write_LCD_REG_DATA(0xC4);//
//Write_LCD_REG_CMD(0x35);
//Write_LCD_REG_DATA(0x00);
//Write_LCD_REG_CMD(0x3A);
//Write_LCD_REG_DATA(0x50);
Write_LCD_REG_CMD(0x11);
Write_LCD_REG_DATA(0x00);	
Delay(600);
Write_LCD_REG_CMD(0x29);
Write_LCD_REG_DATA(0x00);
Delay(500);

由于是 RGB 屏幕，RGB 屏幕需要使用独立的接口去写初始化代码，查询屏幕驱动 IC 手册可知是使用的是 3 线 9 BIT SPI 协议：

其通过第一个 BIT 高低区分是 Command 还是 Data。

正常情况下 SPI 发送为 8 Bit 模式，不支持 9 Bit 发送。这里一般采用 GPIO 模拟生成 SPI 时序方式。

先配置设备树，设置对应的引脚

lcd_gpio_0 = <&pio PD 17 GPIO_ACTIVE_LOW>; // RESET
lcd_gpio_1 = <&pio PD 15 GPIO_ACTIVE_LOW>; // SCK
lcd_gpio_2 = <&pio PD 16 GPIO_ACTIVE_LOW>; // SDA
lcd_gpio_3 = <&pio PD 14 GPIO_ACTIVE_LOW>; // CS

然后编写驱动代码，模拟该时序

#define LCD_MOSI_PIN (2)  // lcd_gpio_2
#define LCD_CLK_PIN  (1)  // lcd_gpio_1
#define LCD_RST_PIN  (0)  // lcd_gpio_0
#define LCD_CS_PIN   (3)  // lcd_gpio_3

static void spi_send_data(u32 sel, u8 i)
{
	u8 n;
	for (n = 0; n < 8; n++) {
		if (i & 0x80)
			sunxi_lcd_gpio_set_value(sel, LCD_MOSI_PIN, 1);
		else
			sunxi_lcd_gpio_set_value(sel, LCD_MOSI_PIN, 0);

		i <<= 1;
		sunxi_lcd_gpio_set_value(sel, LCD_CLK_PIN, 0);
		sunxi_lcd_gpio_set_value(sel, LCD_CLK_PIN, 1);
	}
}

static void spi_write_cmd(u32 sel, u8 i)
{
	sunxi_lcd_gpio_set_value(sel, LCD_CS_PIN, 0);
	sunxi_lcd_gpio_set_value(sel, LCD_MOSI_PIN, 0);
	sunxi_lcd_gpio_set_value(sel, LCD_CLK_PIN, 0);
	sunxi_lcd_gpio_set_value(sel, LCD_CLK_PIN, 1);
	spi_send_data(sel, i);
	sunxi_lcd_gpio_set_value(sel, LCD_CS_PIN, 1);
}

static void spi_write_data(u32 sel, u8 i)
{
	sunxi_lcd_gpio_set_value(sel, LCD_CS_PIN, 0);
	sunxi_lcd_gpio_set_value(sel, LCD_MOSI_PIN, 1);
	sunxi_lcd_gpio_set_value(sel, LCD_CLK_PIN, 0);
	sunxi_lcd_gpio_set_value(sel, LCD_CLK_PIN, 1);
	spi_send_data(sel, i);
	sunxi_lcd_gpio_set_value(sel, LCD_CS_PIN, 1);
}

实现屏幕初始化

把上面实现的 GPIO 模拟 3SPI 函数写入驱动程序。

然后实现 LCD_panel_init 函数内容，写入初始化时序。

实现开关屏函数，主要是操作 RST 引脚

实现完整驱动

完整驱动如下：

头文件：

#ifndef __f450003_H__
#define  __f450003_H__

#include "panels.h"

extern struct __lcd_panel f450003;

#endif

驱动：

#include "f450003.h"

#define LCD_MOSI_PIN (2)  // lcd_gpio_2
#define LCD_CLK_PIN  (1)  // lcd_gpio_1
#define LCD_RST_PIN  (0)  // lcd_gpio_0
#define LCD_CS_PIN   (3)  // lcd_gpio_3

static void LCD_power_on(u32 sel);
static void LCD_power_off(u32 sel);
static void LCD_bl_open(u32 sel);
static void LCD_bl_close(u32 sel);

static void LCD_panel_init(u32 sel);
static void LCD_panel_exit(u32 sel);

static void LCD_cfg_panel_info(struct panel_extend_para *info)
{
	u32 i = 0, j = 0;
	u32 items;
	u8 lcd_gamma_tbl[][2] = {
		/* {input value, corrected value} */
		{0, 0},
		{15, 15},
		{30, 30},
		{45, 45},
		{60, 60},
		{75, 75},
		{90, 90},
		{105, 105},
		{120, 120},
		{135, 135},
		{150, 150},
		{165, 165},
		{180, 180},
		{195, 195},
		{210, 210},
		{225, 225},
		{240, 240},
		{255, 255},
	};

	u32 lcd_cmap_tbl[2][3][4] = {
		{
		{LCD_CMAP_G0, LCD_CMAP_B1, LCD_CMAP_G2, LCD_CMAP_B3},
		{LCD_CMAP_B0, LCD_CMAP_R1, LCD_CMAP_B2, LCD_CMAP_R3},
		{LCD_CMAP_R0, LCD_CMAP_G1, LCD_CMAP_R2, LCD_CMAP_G3},
		},
		{
		{LCD_CMAP_B3, LCD_CMAP_G2, LCD_CMAP_B1, LCD_CMAP_G0},
		{LCD_CMAP_R3, LCD_CMAP_B2, LCD_CMAP_R1, LCD_CMAP_B0},
		{LCD_CMAP_G3, LCD_CMAP_R2, LCD_CMAP_G1, LCD_CMAP_R0},
		},
	};

	items = sizeof(lcd_gamma_tbl) / 2;
	for (i = 0; i < items - 1; i++) {
		u32 num = lcd_gamma_tbl[i + 1][0] - lcd_gamma_tbl[i][0];

		for (j = 0; j < num; j++) {
			u32 value = 0;

			value =
				lcd_gamma_tbl[i][1] +
				((lcd_gamma_tbl[i + 1][1] -
				lcd_gamma_tbl[i][1]) * j) / num;
			info->lcd_gamma_tbl[lcd_gamma_tbl[i][0] + j] =
				(value << 16) + (value << 8) + value;
		}
	}
	info->lcd_gamma_tbl[255] =
		(lcd_gamma_tbl[items - 1][1] << 16) +
		(lcd_gamma_tbl[items - 1][1] << 8) + lcd_gamma_tbl[items - 1][1];

	memcpy(info->lcd_cmap_tbl, lcd_cmap_tbl, sizeof(lcd_cmap_tbl));

}

static s32 LCD_open_flow(u32 sel)
{
	/* open lcd power, and delay 50ms */
	LCD_OPEN_FUNC(sel, LCD_power_on, 30);
	/* open lcd power, than delay 200ms */
	LCD_OPEN_FUNC(sel, LCD_panel_init, 50);
	/* open lcd controller, and delay 100ms */
	LCD_OPEN_FUNC(sel, sunxi_lcd_tcon_enable, 100);
	/* open lcd backlight, and delay 0ms */
	LCD_OPEN_FUNC(sel, LCD_bl_open, 0);

	return 0;
}

static s32 LCD_close_flow(u32 sel)
{
	/* close lcd backlight, and delay 0ms */
	LCD_CLOSE_FUNC(sel, LCD_bl_close, 0);
	/* close lcd controller, and delay 0ms */
	LCD_CLOSE_FUNC(sel, sunxi_lcd_tcon_disable, 0);
	/* open lcd power, than delay 200ms */
	LCD_CLOSE_FUNC(sel, LCD_panel_exit, 200);
	/* close lcd power, and delay 500ms */
	LCD_CLOSE_FUNC(sel, LCD_power_off, 500);

	return 0;
}

static void LCD_power_on(u32 sel)
{
	/* config lcd_power pin to open lcd power0 */
	sunxi_lcd_power_enable(sel, 0);
	sunxi_lcd_gpio_set_value(0, LCD_RST_PIN, 0);
	sunxi_lcd_delay_ms(100);
	sunxi_lcd_gpio_set_value(0, LCD_RST_PIN, 1);
	sunxi_lcd_pin_cfg(sel, 1);
}

static void LCD_power_off(u32 sel)
{
	sunxi_lcd_pin_cfg(sel, 0);
	/* config lcd_power pin to close lcd power0 */
	sunxi_lcd_gpio_set_value(0, LCD_RST_PIN, 0);
	sunxi_lcd_power_disable(sel, 0);
}

static void LCD_bl_open(u32 sel)
{
	sunxi_lcd_pwm_enable(sel);
	sunxi_lcd_backlight_enable(sel);
}

static void LCD_bl_close(u32 sel)
{
	/* config lcd_bl_en pin to close lcd backlight */
	sunxi_lcd_backlight_disable(sel);
	sunxi_lcd_pwm_disable(sel);
}

static void spi_send_data(u32 sel, u8 i)
{
	u8 n;
	for (n = 0; n < 8; n++) {
		if (i & 0x80)
			sunxi_lcd_gpio_set_value(sel, LCD_MOSI_PIN, 1);
		else
			sunxi_lcd_gpio_set_value(sel, LCD_MOSI_PIN, 0);

		i <<= 1;
		sunxi_lcd_gpio_set_value(sel, LCD_CLK_PIN, 0);
		sunxi_lcd_gpio_set_value(sel, LCD_CLK_PIN, 1);
	}
}

static void spi_write_cmd(u32 sel, u8 i)
{
	sunxi_lcd_gpio_set_value(sel, LCD_CS_PIN, 0);
	sunxi_lcd_gpio_set_value(sel, LCD_MOSI_PIN, 0);
	sunxi_lcd_gpio_set_value(sel, LCD_CLK_PIN, 0);
	sunxi_lcd_gpio_set_value(sel, LCD_CLK_PIN, 1);
	spi_send_data(sel, i);
	sunxi_lcd_gpio_set_value(sel, LCD_CS_PIN, 1);
}

static void spi_write_data(u32 sel, u8 i)
{
	sunxi_lcd_gpio_set_value(sel, LCD_CS_PIN, 0);
	sunxi_lcd_gpio_set_value(sel, LCD_MOSI_PIN, 1);
	sunxi_lcd_gpio_set_value(sel, LCD_CLK_PIN, 0);
	sunxi_lcd_gpio_set_value(sel, LCD_CLK_PIN, 1);
	spi_send_data(sel, i);
	sunxi_lcd_gpio_set_value(sel, LCD_CS_PIN, 1);
}

static void LCD_panel_init(u32 sel)
{
	spi_write_cmd(sel, 0x01);
	sunxi_lcd_delay_ms(6);
	spi_write_cmd(sel, 0xFF);
	spi_write_data(sel, 0x30);
	spi_write_cmd(sel, 0xFF);
	spi_write_data(sel, 0x49);
	spi_write_cmd(sel, 0xFF);
	spi_write_data(sel, 0x01);
	spi_write_cmd(sel, 0xe2);
	spi_write_data(sel, 0x00);
	spi_write_cmd(sel, 0xe2);
	spi_write_data(sel, 0x00);
	// spi_write_cmd(sel, 0xF1);
	// spi_write_data(sel, 0x0e); //bist
	spi_write_cmd(sel, 0x14);
	spi_write_data(sel, 0x08); //vbp_para[7:0]
	spi_write_cmd(sel, 0x11);
	spi_write_data(sel, 0x08); //vfp_para[7:0]
	spi_write_cmd(sel, 0x16);
	spi_write_data(sel, 0x14); //hfp
	spi_write_cmd(sel, 0x19);
	spi_write_data(sel, 0x19); //hbp
	spi_write_cmd(sel, 0x15); //vbp_seri[7:0]
	spi_write_data(sel, 0x08);
	spi_write_cmd(sel, 0x12); //vfp_seri[7:0]
	spi_write_data(sel, 0x08);
	spi_write_cmd(sel, 0x17); //hfp_seri
	spi_write_data(sel, 0x14);
	spi_write_cmd(sel, 0x1A); //hbp_seri
	spi_write_data(sel, 0x19);
	spi_write_cmd(sel, 0x20);
	spi_write_data(sel, 0x5c);
	spi_write_cmd(sel, 0x21);
	spi_write_data(sel, 0x02);
	spi_write_cmd(sel, 0x3b);
	spi_write_data(sel, 0x04); //LVD
	spi_write_cmd(sel, 0x41);
	spi_write_data(sel, 0x32);
	spi_write_cmd(sel, 0x45);
	spi_write_data(sel, 0x03);
	spi_write_cmd(sel, 0x46);
	spi_write_data(sel, 0x55);
	//////////////SOURCE/////////////////
	spi_write_cmd(sel, 0x51);
	spi_write_data(sel, 0x36);
	spi_write_cmd(sel, 0x52);
	spi_write_data(sel, 0x01);
	spi_write_cmd(sel, 0x53);
	spi_write_data(sel, 0x20);
	spi_write_cmd(sel, 0x54);
	spi_write_data(sel, 0x12);
	spi_write_cmd(sel, 0x55);
	spi_write_data(sel, 0x01);
	spi_write_cmd(sel, 0x56);
	spi_write_data(sel, 0x03);
	spi_write_cmd(sel, 0x57);
	spi_write_data(sel, 0x37);
	//Write_LCD_REG(0x0000,0x0059);
	//Write_LCD_REG(0x0000,0x0100);
	//Write_LCD_REG(0x0000,0x005A);
	//Write_LCD_REG(0x0000,0x0100);
	spi_write_cmd(sel, 0x5B);
	spi_write_data(sel, 0x82);
	spi_write_cmd(sel, 0x5C);
	spi_write_data(sel, 0x10);
	spi_write_cmd(sel, 0x5D);
	spi_write_data(sel, 0x80); //
	spi_write_cmd(sel, 0x79);
	spi_write_data(sel, 0xFE);
	spi_write_cmd(sel, 0x7D);
	spi_write_data(sel, 0x08);
	//////////////SOURCE/////////////////
	spi_write_cmd(sel, 0x90);
	spi_write_data(sel, 0x00); //VSP
	spi_write_cmd(sel, 0x91);
	spi_write_data(sel, 0x00); //VSN
	spi_write_cmd(sel, 0x95);
	spi_write_data(sel, 0x0c);
	spi_write_cmd(sel, 0x94);
	spi_write_data(sel, 0x08);
	spi_write_cmd(sel, 0x96);
	spi_write_data(sel, 0x16);
	spi_write_cmd(sel, 0x98);
	spi_write_data(sel, 0x33);
	spi_write_cmd(sel, 0xca);
	spi_write_data(sel, 0x14);
	spi_write_cmd(sel, 0xc8);
	spi_write_data(sel, 0x6e);
	spi_write_cmd(sel, 0xcc);
	spi_write_data(sel, 0x12);
	spi_write_cmd(sel, 0xe7);
	spi_write_data(sel, 0x30);
	spi_write_cmd(sel, 0xA0);
	spi_write_data(sel, 0x30);
	spi_write_cmd(sel, 0xB4);
	spi_write_data(sel, 0x30);
	spi_write_cmd(sel, 0xA1);
	spi_write_data(sel, 0x22);
	spi_write_cmd(sel, 0xB5);
	spi_write_data(sel, 0x21);
	spi_write_cmd(sel, 0xA2);
	spi_write_data(sel, 0x20);
	spi_write_cmd(sel, 0xB6);
	spi_write_data(sel, 0x1E);
	spi_write_cmd(sel, 0xA5);
	spi_write_data(sel, 0x0F);
	spi_write_cmd(sel, 0xB9);
	spi_write_data(sel, 0x11);
	spi_write_cmd(sel, 0xA6);
	spi_write_data(sel, 0x08);
	spi_write_cmd(sel, 0xBA);
	spi_write_data(sel, 0x07);
	spi_write_cmd(sel, 0xA7);
	spi_write_data(sel, 0x08);
	spi_write_cmd(sel, 0xBB);
	spi_write_data(sel, 0x08);
	spi_write_cmd(sel, 0xA3);
	spi_write_data(sel, 0x40);
	spi_write_cmd(sel, 0xB7);
	spi_write_data(sel, 0x42);
	spi_write_cmd(sel, 0xA4);
	spi_write_data(sel, 0x40);
	spi_write_cmd(sel, 0xB8);
	spi_write_data(sel, 0x42);
	spi_write_cmd(sel, 0xA8);
	spi_write_data(sel, 0x0F);
	spi_write_cmd(sel, 0xBC);
	spi_write_data(sel, 0x0E);
	spi_write_cmd(sel, 0xA9);
	spi_write_data(sel, 0x15);
	spi_write_cmd(sel, 0xBD);
	spi_write_data(sel, 0x14);
	spi_write_cmd(sel, 0xAA);
	spi_write_data(sel, 0x15);
	spi_write_cmd(sel, 0xBE);
	spi_write_data(sel, 0x15);
	spi_write_cmd(sel, 0xAB);
	spi_write_data(sel, 0x15);
	spi_write_cmd(sel, 0xBF);
	spi_write_data(sel, 0x14);
	spi_write_cmd(sel, 0xAC);
	spi_write_data(sel, 0x10);
	spi_write_cmd(sel, 0xC0);
	spi_write_data(sel, 0x10);
	spi_write_cmd(sel, 0xAD);
	spi_write_data(sel, 0x11);
	spi_write_cmd(sel, 0xC1);
	spi_write_data(sel, 0x12);
	spi_write_cmd(sel, 0xAE);
	spi_write_data(sel, 0x10);
	spi_write_cmd(sel, 0xC2);
	spi_write_data(sel, 0x13);
	spi_write_cmd(sel, 0xAF);
	spi_write_data(sel, 0x0f);
	spi_write_cmd(sel, 0xC3);
	spi_write_data(sel, 0x12);
	spi_write_cmd(sel, 0xB0);
	spi_write_data(sel, 0x10);
	spi_write_cmd(sel, 0xC4);
	spi_write_data(sel, 0x10);
	spi_write_cmd(sel, 0xB1);
	spi_write_data(sel, 0x08);
	spi_write_cmd(sel, 0xC5);
	spi_write_data(sel, 0x0A);
	spi_write_cmd(sel, 0xFF);
	spi_write_data(sel, 0x30);
	spi_write_cmd(sel, 0xFF);
	spi_write_data(sel, 0x49);
	spi_write_cmd(sel, 0xFF);
	spi_write_data(sel, 0x03);
	///////////////////////////GOA//////////////////////////////
	spi_write_cmd(sel, 0x27);
	spi_write_data(sel, 0x88);
	spi_write_cmd(sel, 0x28);
	spi_write_data(sel, 0x06);
	spi_write_cmd(sel, 0x29);
	spi_write_data(sel, 0x04);
	spi_write_cmd(sel, 0x36);
	spi_write_data(sel, 0x88);
	spi_write_cmd(sel, 0x37);
	spi_write_data(sel, 0x05);
	spi_write_cmd(sel, 0x38);
	spi_write_data(sel, 0x03);
	spi_write_cmd(sel, 0x2a);
	spi_write_data(sel, 0x11);
	spi_write_cmd(sel, 0x2b);
	spi_write_data(sel, 0x60);
	spi_write_cmd(sel, 0x2c);
	spi_write_data(sel, 0x80);
	spi_write_cmd(sel, 0x79);
	spi_write_data(sel, 0x3f);
	spi_write_cmd(sel, 0x7a);
	spi_write_data(sel, 0x3f);
	spi_write_cmd(sel, 0x7B);
	spi_write_data(sel, 0x30);
	spi_write_cmd(sel, 0x80);
	spi_write_data(sel, 0x85);
	spi_write_cmd(sel, 0x81);
	spi_write_data(sel, 0x13);
	spi_write_cmd(sel, 0x82);
	spi_write_data(sel, 0x5a);
	spi_write_cmd(sel, 0x83);
	spi_write_data(sel, 0x05);
	spi_write_cmd(sel, 0x84);
	spi_write_data(sel, 0x60);
	spi_write_cmd(sel, 0x85);
	spi_write_data(sel, 0x80);
	spi_write_cmd(sel, 0x88);
	spi_write_data(sel, 0x84);
	spi_write_cmd(sel, 0x89);
	spi_write_data(sel, 0x13);
	spi_write_cmd(sel, 0x8A);
	spi_write_data(sel, 0x5b);
	spi_write_cmd(sel, 0x8B);
	spi_write_data(sel, 0x11);
	spi_write_cmd(sel, 0x8C);
	spi_write_data(sel, 0x60);
	spi_write_cmd(sel, 0x8D);
	spi_write_data(sel, 0x80);
	spi_write_cmd(sel, 0x8E);
	spi_write_data(sel, 0x83);
	spi_write_cmd(sel, 0x8F);
	spi_write_data(sel, 0x13);
	spi_write_cmd(sel, 0x90);
	spi_write_data(sel, 0x5c);
	spi_write_cmd(sel, 0x91);
	spi_write_data(sel, 0x11);
	spi_write_cmd(sel, 0x92);
	spi_write_data(sel, 0x60);
	spi_write_cmd(sel, 0x93);
	spi_write_data(sel, 0x80);
	spi_write_cmd(sel, 0x94);
	spi_write_data(sel, 0x82);
	spi_write_cmd(sel, 0x95);
	spi_write_data(sel, 0x13);
	spi_write_cmd(sel, 0x96);
	spi_write_data(sel, 0x5d);
	spi_write_cmd(sel, 0x97);
	spi_write_data(sel, 0x11);
	spi_write_cmd(sel, 0x98);
	spi_write_data(sel, 0x60);
	spi_write_cmd(sel, 0x99);
	spi_write_data(sel, 0x80);
	///////////////////////////GOA//////////////////////////////
	/////////////////////////GOA MAP//////////////////////
	spi_write_cmd(sel, 0xD0);
	spi_write_data(sel, 0x1F);
	spi_write_cmd(sel, 0xD1);
	spi_write_data(sel, 0x1A);
	spi_write_cmd(sel, 0xD2);
	spi_write_data(sel, 0x0A);
	spi_write_cmd(sel, 0xD3);
	spi_write_data(sel, 0x0C);
	spi_write_cmd(sel, 0xD4);
	spi_write_data(sel, 0x04);
	spi_write_cmd(sel, 0xD5);
	spi_write_data(sel, 0x1B);
	spi_write_cmd(sel, 0xD6);
	spi_write_data(sel, 0x1F);
	spi_write_cmd(sel, 0xD7);
	spi_write_data(sel, 0x1F);
	spi_write_cmd(sel, 0xD8);
	spi_write_data(sel, 0x1F);
	spi_write_cmd(sel, 0xD9);
	spi_write_data(sel, 0x1F);
	spi_write_cmd(sel, 0xDA);
	spi_write_data(sel, 0x1f);
	spi_write_cmd(sel, 0xDB);
	spi_write_data(sel, 0x1f);
	spi_write_cmd(sel, 0xDC);
	spi_write_data(sel, 0x1F);
	spi_write_cmd(sel, 0xDD);
	spi_write_data(sel, 0x1F);
	spi_write_cmd(sel, 0xDE);
	spi_write_data(sel, 0x1F);
	spi_write_cmd(sel, 0xDF);
	spi_write_data(sel, 0x1F);
	spi_write_cmd(sel, 0xE0);
	spi_write_data(sel, 0x1F);
	spi_write_cmd(sel, 0xE1);
	spi_write_data(sel, 0x1F);
	spi_write_cmd(sel, 0xE2);
	spi_write_data(sel, 0x1f);
	spi_write_cmd(sel, 0xE3);
	spi_write_data(sel, 0x1f);
	spi_write_cmd(sel, 0xE4);
	spi_write_data(sel, 0x1f);
	spi_write_cmd(sel, 0xE5);
	spi_write_data(sel, 0x1f);
	spi_write_cmd(sel, 0xE6);
	spi_write_data(sel, 0x1F);
	spi_write_cmd(sel, 0xE7);
	spi_write_data(sel, 0x1F);
	spi_write_cmd(sel, 0xE8);
	spi_write_data(sel, 0x1F);
	spi_write_cmd(sel, 0xE9);
	spi_write_data(sel, 0x1F);
	spi_write_cmd(sel, 0xEA);
	spi_write_data(sel, 0x1B);
	spi_write_cmd(sel, 0xEB);
	spi_write_data(sel, 0x05);
	spi_write_cmd(sel, 0xEC);
	spi_write_data(sel, 0x0D);
	spi_write_cmd(sel, 0xED);
	spi_write_data(sel, 0x0B);
	spi_write_cmd(sel, 0xEE);
	spi_write_data(sel, 0x1A);
	spi_write_cmd(sel, 0xEF);
	spi_write_data(sel, 0x1F);
	/////////////////////////GOA MAP//////////////////////
	//Write_LCD_REG(0x0000,0x00f7);
	//Write_LCD_REG(0x0000,0x0120);
	//Write_LCD_REG(0x0000,0x00f8);
	//Write_LCD_REG(0x0000,0x0120);
	//HL Temp test
	spi_write_cmd(sel, 0xf7);
	spi_write_data(sel, 0x50);
	spi_write_cmd(sel, 0xf8);
	spi_write_data(sel, 0x50);
	spi_write_cmd(sel, 0xFF);
	spi_write_data(sel, 0x30);
	spi_write_cmd(sel, 0xFF);
	spi_write_data(sel, 0x49);
	spi_write_cmd(sel, 0xFF);
	spi_write_data(sel, 0x00);
	spi_write_cmd(sel, 0xF1);
	spi_write_data(sel, 0xC4); //
	//Write_LCD_REG(0x0000,0x0035);
	//Write_LCD_REG(0x0000,0x0100);
	//Write_LCD_REG(0x0000,0x003A);
	//Write_LCD_REG(0x0000,0x0150);
	//spi_write_cmd(sel, 0x21);
	//spi_write_data(sel, 0x00);
	spi_write_cmd(sel, 0x11);
	spi_write_data(sel, 0x00);
	sunxi_lcd_delay_ms(200);
	spi_write_cmd(sel, 0x29);
	spi_write_data(sel, 0x00);
}

static void LCD_panel_exit(u32 sel)
{
	spi_write_cmd(sel, 0x10);
	spi_write_cmd(sel, 0x28);
}

/* sel: 0:lcd0; 1:lcd1 */
static s32 LCD_user_defined_func(u32 sel, u32 para1, u32 para2, u32 para3)
{
	return 0;
}

struct __lcd_panel f450003 = {
	/* panel driver name, must mach the lcd_drv_name in sys_config.fex */
	.name = "f450003",
	.func = {
		.cfg_panel_info = LCD_cfg_panel_info,
		.cfg_open_flow = LCD_open_flow,
		.cfg_close_flow = LCD_close_flow,
		.lcd_user_defined_func = LCD_user_defined_func,
		}
	,
};

配置编译驱动

编辑 bsp/drivers/video/sunxi/disp2/disp/lcd/Kconfig 文件，增加新驱动配置

config LCD_SUPPORT_F450003
	bool "LCD support F450003 panel"
	default n
	help
		if you want to support F450003 panel for display driver, select it.

编辑 bsp/drivers/video/sunxi/disp2/disp/Makefile 增加配置

disp-$(CONFIG_LCD_SUPPORT_F450003) += lcd/f450003.o

编辑 bsp/drivers/video/sunxi/disp2/disp/lcd/panels.c 新增屏幕引用

#if IS_ENABLED(CONFIG_LCD_SUPPORT_F450003)
	&f450003_panel,
#endif

编辑 bsp/drivers/video/sunxi/disp2/disp/lcd/panels.h 新增屏幕引用

#if IS_ENABLED(CONFIG_LCD_SUPPORT_F450003)
extern struct __lcd_panel f450003_panel;
#endif

获取屏幕时序

由于使用的是 Serial RGB，其 RGB 时序参考入下图所示。

屏幕时序参数与屏幕时间显示数据如下图所示：

这里需要注意的是，对于该接口，SoC总共需要三个周期才能发完一个pixel，所以我们配置时序的时候，需要满足

$\text{lcd\_dclk\_freq} \times 3 = \text{lcd\_ht} \times \text{lcd\_vt} \times 60$

或者

$\text{lcd\_dclk\_freq} = \text{lcd\_ht} \times 3 \times \text{lcd\_vt} \times 60$

要么配置 3 倍 lcd_ht 要么 3 倍 lcd_dclk_freq。

此时一般询问屏厂，让其提供 RGB 时序配置，将时序参数配置为：

lcd_dclk_freq       = <77>;
lcd_hbp             = <23>;
lcd_ht              = <1479>;
lcd_hspw            = <2>;
lcd_vbp             = <8>;
lcd_vt              = <870>;
lcd_vspw            = <2>;

配置设备树

设备树配置如下：

&disp {
	disp_init_enable         = <1>;
	disp_mode                = <0>;

	screen0_output_type      = <1>;
	screen0_output_mode      = <4>;
	screen0_to_lcd_index     = <0>;

	screen1_output_type      = <3>;
	screen1_output_mode      = <10>;
	screen1_to_lcd_index     = <2>;

	screen1_output_format    = <0>;
	screen1_output_bits      = <0>;
	screen1_output_eotf      = <4>;
	screen1_output_cs        = <257>;
	screen1_output_dvi_hdmi  = <2>;
	screen1_output_range     = <2>;
	screen1_output_scan      = <0>;
	screen1_output_aspect_ratio = <8>;

	fb_format                = <0>;
	fb_num                   = <1>;
	fb_debug                 = <1>;
	/*<disp channel layer zorder>*/
	fb0_map                  = <0 0 0 16>;
	fb0_width                = <480>;
	fb0_height               = <854>;
	/*<disp channel layer zorder>*/
	fb1_map                  = <0 2 0 16>;
	fb1_width                = <300>;
	fb1_height               = <300>;
	/*<disp channel layer zorder>*/
	fb2_map                  = <1 0 0 16>;
	fb2_width                = <1280>;
	fb2_height               = <720>;
	/*<disp channel layer zorder>*/
	fb3_map                  = <1 1 0 16>;
	fb3_width                = <300>;
	fb3_height               = <300>;

	chn_cfg_mode             = <1>;
	disp_para_zone           = <1>;
};

&lcd0 {
	lcd_used            = <1>;

	lcd_driver_name     = "f450003";
	lcd_backlight       = <50>;
	lcd_if              = <0>;

	lcd_x               = <480>;
	lcd_y               = <854>;
	lcd_width           = <60>;
	lcd_height          = <100>;
	lcd_dclk_freq       = <71>;

	lcd_pwm_used        = <0>;
	lcd_pwm_ch          = <7>;
	lcd_pwm_freq        = <50000>;
	lcd_pwm_pol         = <0>;

	lcd_hbp             = <23>;
	lcd_ht              = <1479>;
	lcd_hspw            = <2>;
	lcd_vbp             = <8>;
	lcd_vt              = <870>;
	lcd_vspw            = <2>;

	lcd_frm             = <0>;
	lcd_io_phase        = <0x0000>;
	lcd_gamma_en        = <0>;
	lcd_bright_curve_en = <0>;
	lcd_cmap_en         = <0>;

	deu_mode            = <0>;
	lcdgamma4iep        = <22>;
	smart_color         = <90>;
	lcd_hv_if           = <8>;
	lcd_hv_clk_phase    = <1>;

	lcd_hv_srgb_seq      = <10>;
	lcd_hv_sync_polarity = <0>;

	lcd_gpio_0 = <&pio PD 17 GPIO_ACTIVE_LOW>; // RST
	lcd_gpio_1 = <&pio PD 15 GPIO_ACTIVE_LOW>; // SCK
	lcd_gpio_2 = <&pio PD 16 GPIO_ACTIVE_LOW>; // SDA
	lcd_gpio_3 = <&pio PD 14 GPIO_ACTIVE_LOW>; // CS

	pinctrl-0 = <&rgb8_pins_a>, <&rgb8_pins_ctl_a>;
	pinctrl-1 = <&rgb8_pins_b>, <&rgb8_pins_ctl_b>;
};

测试屏幕

使用命令查看 TCON 彩条，这个彩条是由 TCON 发出的，操作更加底层。

echo 1 > /sys/class/disp/disp/attr/colorbar

使用命令查看 DE 彩条，这个彩条是由 DE 合成发出的，如果 DE 出问题则可以看到 TCON 彩条看不到 DE 彩条。

提示

如果刚才开了 TCON 彩条，记得先关一下，TCON 彩条优先级更高

echo 0 > /sys/class/disp/disp/attr/colorbar

echo 8 > /sys/class/disp/disp/attr/colorbar

FAQ

RGB接口显示抖动有花纹

1. 改大时钟管脚的管脚驱动能力，改大。
2. 修改时钟相位，也就是修改 lcd_hv_clk_phase。由于发送端和接收端时钟相位的不同导致接收端解错若干位。

黑屏无显示

黑屏，没有屏幕信号输出

注意芯片型号！

首先确认芯片型号是否为 V821L2-WXX，其他型号不支持 I8080 显示。

完全黑屏，背光也没有

1. 屏驱动添加失败。驱动没有加载屏驱动，导致背光电源相关函数没有运行到。
2. 屏驱动加载成功，但是没有执行到开背光函数（可以在uboot的屏驱动中加打印确认开屏流程的执行情况）。这时候大概率是屏驱动的开屏函数没有执行完，uboot就执行完毕进入内核了。需要在满足屏手册上电时序要求的情况下，尽量减少延迟。
3. PWM 配置和背光电路的问题，另外就是直接测量下硬件测量下相关管脚和电压，再检查屏是否初始化成功。

黑屏但是有背光

1. 没送图层。如果应用没有送任何图层那么表现的现象就是黑屏。
2. SoC端的显示接口模块没有供电。SoC端模块没有供电自然无法传输视频信号到屏上。
3. 复位脚没有复位。如果有复位脚，请确保硬件连接正确，确保复位脚的复位操作有放到屏驱动中。
4. board.dts 中 lcd0有严重错误。第一个是 lcd的timing搞错了，请严格按照屏手册中的提示来写。第二个就是，接口类型搞错。
5. 屏的初始化命令不对。包括各个步骤先后顺序，延时等，这个时候请找屏厂确认初始化命令。